<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<style type="text/css">

html {
    height:100%; /* fix height to 100% for IE */
    width: 100%;
    max-height:100%; /* fix height for other browsers */
    padding:0; /*remove padding */
    margin:0; /* remove margins */
    border:0; /* remove borders */
}

.ptitle h2 {
    text-align: center
}

.stitle {
    font-size: 100%;
    font-weight: bold;
    text-align: left;
}

.headcontent {
    font-size: 90%;
    max-height: 200px;
}

.toc {
    display: inline-block;
}

.summary {
    margin:0;
    padding:0;
    background:transparent;
    height:100%;
    margin-right:100px;
    padding-right:100px;
    padding-top:10px;
    display: inline-block;
    float:right;
}

.toc ol {
    margin:0;
    padding:0;
    background:transparent;
    height:100%;
    margin-left:50px;
    padding-left:10px;
    padding-top:10px;
}

.toc ol li a { padding-left:20px;  color: #0000EE;; text-decoration:none;}
.toc ol li a:hover { color:#BABABA;  }
a:hover { color:#BABABA;  }
.diagrams { display: inline-block;}

.rgtable td { width:70px; text-align:center;}


td {
  font-family:Consolas,Monaco,Lucida Console,Liberation Mono,DejaVu Sans Mono,Bitstream Vera Sans Mono,Courier New, monospace;
}

.pie-container {
box-sizing: border-box;
width: 850px;
height: 450px;
padding: 20px 15px 15px 15px;
margin: 15px auto 30px auto;
border: 1px solid #ddd;
background: #fff;
background: linear-gradient(#f6f6f6 0, #fff 50px);
background: -o-linear-gradient(#f6f6f6 0, #fff 50px);
background: -ms-linear-gradient(#f6f6f6 0, #fff 50px);
background: -moz-linear-gradient(#f6f6f6 0, #fff 50px);
background: -webkit-linear-gradient(#f6f6f6 0, #fff 50px);
box-shadow: 0 3px 10px rgba(0,0,0,0.15);
-o-box-shadow: 0 3px 10px rgba(0,0,0,0.1);
-ms-box-shadow: 0 3px 10px rgba(0,0,0,0.1);
-moz-box-shadow: 0 3px 10px rgba(0,0,0,0.1);
-webkit-box-shadow: 0 3px 10px rgba(0,0,0,0.1);
}

.pie-placeholder {
width: 100%;
height: 100%;
font-size: 14px;
line-height: 1.2em;
}

.metricstable,table,td,th
{
border-style:    none;
border-color:    white;
border-collapse: collapse;
border-width:    1px;
padding: 0px;
}

.padded { padding: 0 10px; }

.paddedleft { padding: 0 10px; text-align: left; }
.paddedright { padding: 0 10px; text-align: right; }

.lightheader { background-color: lightgreen; }
.boldheader  { background-color: lime; }

.docTable,table,th
{
border-style:   solid;
border-color:   black;
border-width:   1px;
background:     lightgray;
}
.docTable,table,td
{
border-style:   solid;
border-color:   black;
border-width:   1px;
background:     white;
}
.docCellGreen
{
border-style:   solid;
border-color:   black;
border-width:   1px;
background:     green;
}
.docCellRed
{
border-style:   solid;
border-color:   black;
border-width:   1px;
background:     red;
}
.docCellOrange
{
border-style:   solid;
border-color:   black;
border-width:   1px;
background:     orange;
}
.docCellBlue
{
border-style:   solid;
border-color:   black;
border-width:   1px;
background:     DeepSkyBlue;
}
</style>
<title>PRQA GEP/GCS/GRP Report</title>
</head>
<body>
  <div id="head">
  <div class="ptitle"><h2>PRQA GEP/GCS/GRP Report</h2></div>
  <div class="stitle"><h4><i>Note: This report is generated using the software (PRQA Framework) of Programming Research Limited and is the Intellectual Property of Programming Research Limited.</i></h4></div>
  <div class="stitle">Project &nbsp;&nbsp;: .../ST25R3916_nucleo/nucleo/Firmware/nucleo/X-NUCLEO-NFC06A1/STM32<br/>Status at: 20 May, 2020 at 18:40:07<br/><i>MISRA report script last update: 01/07/19</i></div>
  <div class="headcontent">
    <div class="toc">
      <ol>
        <li><a href="#GEP">GEP - Guideline Enforcement Plan</a></li>
          <ol>
            <li><a href="#Tools">Tools version</a></li>
            <li><a href="#Configuration">Configuration files</a></li>
            <li><a href="#Assistance">Assistance/Enforcement</a></li>
          </ol>
        <li><a href="#GRP">GRP - Guideline Recategorization Plan</a></li>
        <li><a href="#GCS">GCS - Guideline Compliance Summary</a></li>
        <li><a href="#Permits">Deviation Permits</a></li>
        <li><a href="#Records">Deviation Records</a></li>
          <ol>
            <li><a href="#SuppressionsByFile">Suppressions by File</a></li>
            <li><a href="#SuppressionsByGroup">Suppressions by Group</a></li>
            <li><a href="#RedundantSuppressions">Redundant Suppressions</a></li>
            <li><a href="#ContinuousSuppressionsByFile">Continuous Suppressions by File</a></li>
            <li><a href="#FileStatus">File Status</a></li>
          </ol>
      </ol>
    </div>
  </div>
  </div>

<br>
<br>
<br>
<div id="content">
<div class="GEP">
<div class="sec"><h2><a name="GEP">GEP - Guideline Enforcement Plan</a></h2></div>
This section targets to provide an overview of Guidelines Enforcement Plan (GEP).<br>
 <br>
This document will only focus on STMicroelectronics NFC RF Abstraction Layer (RFAL).<br>
 <br>
The project has been designed to comply with the standard ISO/IEC 9899:1999 ([C99]).
<br>
<br>
<h3><a name="Tools">1. Tools version</a></h3>
The tool used for MISRA compliance is:<br>
<br>
<b>PRQA Framework - v2.2.2</b><br>
<br><br>
It is composed of the following subcomponents:
<br><br>
<ul>
<li><h4>Component: qacpp</h4></li>
<ul>Version: 4.2.0</ul>
<ul>Target: C++</ul>
<li><h4>Component: rcma</h4></li>
<ul>Version: 1.6.0</ul>
<ul>Target: C_CPP</ul>
<li><h4>Component: m3cm</h4></li>
<ul>Version: 2.3.1</ul>
<ul>Target: C</ul>
<li><h4>Component: qac</h4></li>
<ul>Version: 9.3.1</ul>
<ul>Target: C</ul>
<ul>
<li><h5>Options:</h5></li>
<ul>-d : __schedule_barrier=_ignore_semi</ul>
<ul>-namelength : 63</ul>
</ul>
</ul>
<h3><a name="Configuration">2. Configuration</a></h3>
This section targets to provide the main configuration options used for MISRA compliance.<br>
 <br>
The project complies to [C99],<br>
the variables length has been consequently set to a dedicated value (cf 'namelength' option in table above).
<br>
<br>
<b>Repository/components:</b><br>
  <ul>
    <li>MCU target:</li>
      <ul>STM32</ul><br>
    <li>Parent repository:</li>
      <ul>ST25R3916_nucleo</ul><br>
    <li>RFAL information:</li>
      <ul>Path: .../ST25R3916_nucleo/rfal</ul>
      <ul>Version: v2.1.2</ul>
          <br>    <li>Project repositories SHA1:</li>
      <ul><b>.../ST25R3916_nucleo</b>: 959b80e</ul>
      <ul><b>.../ST25R3916_nucleo/common</b>: 09bc5ef</ul>
      <ul><b>.../ST25R3916_nucleo/nucleo</b>: 22a04ae</ul>
      <ul><b>.../ST25R3916_nucleo/rfal</b>: f08099c</ul>
  <br>
  </ul>
<h3><a name="Assistance">3. Assistance/Enforcement</a></h3>
<center><table class="docTable" width=98%>
  <colgroup span="10" class="columns"></colgroup>
  <tr><th>Guideline</th><th>Category</th><th>Description</th><th>Assistance/Enforcement Sub Rules</th></tr>
  <tr>                                           
    <td width=2%>Dir-1.1</td>
    <td width=2%>Required</td>
    <td width=50%>Any implementation-defined behaviour on which the output of the program depends shall be documented and understood</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0202</td>
    <td width=95%> [I] '-' character in '[]' conversion specification is implementation defined.</td>
  </tr>
  <tr>
    <td width=5%>0284</td>
    <td width=95%> [I] Multiple character constants have implementation defined values.</td>
  </tr>
  <tr>
    <td width=5%>0285</td>
    <td width=95%> [I] Character constant contains character which is not a member of the basic source character set.</td>
  </tr>
  <tr>
    <td width=5%>0286</td>
    <td width=95%> [I] String literal contains character which is not a member of the basic source character set.</td>
  </tr>
  <tr>
    <td width=5%>0287</td>
    <td width=95%> [I] Header name contains character which is not a member of the basic source character set.</td>
  </tr>
  <tr>
    <td width=5%>0288</td>
    <td width=95%> [I] Source file '%s' has comments containing characters which are not members of the basic source character set.</td>
  </tr>
  <tr>
    <td width=5%>0289</td>
    <td width=95%> [I] Source file '%s' has preprocessing tokens containing characters which are not members of the basic source character set.</td>
  </tr>
  <tr>
    <td width=5%>0292</td>
    <td width=95%> [I] Source file '%s' has comments containing one of the characters '$', '@' or '`'.</td>
  </tr>
  <tr>
    <td width=5%>0299</td>
    <td width=95%> [I] Source file '%s' includes #pragma directives containing characters which are not members of the basic source character set.</td>
  </tr>
  <tr>
    <td width=5%>0314</td>
    <td width=95%> [I] Cast from a pointer to object type to a pointer to void.</td>
  </tr>
  <tr>
    <td width=5%>0315</td>
    <td width=95%> [I] Implicit conversion from a pointer to object type to a pointer to void.</td>
  </tr>
  <tr>
    <td width=5%>0371</td>
    <td width=95%> [L] Nesting levels of blocks exceeds 127 - program does not conform strictly to ISO:C99.</td>
  </tr>
  <tr>
    <td width=5%>0372</td>
    <td width=95%> [L] More than 63 levels of nested conditional inclusion - program does not conform strictly to ISO:C99.</td>
  </tr>
  <tr>
    <td width=5%>0375</td>
    <td width=95%> [L] Nesting of parenthesized expressions exceeds 63 - program does not conform strictly to ISO:C99.</td>
  </tr>
  <tr>
    <td width=5%>0380</td>
    <td width=95%> [L] Number of macro definitions exceeds 4095 - program does not conform strictly to ISO:C99.</td>
  </tr>
  <tr>
    <td width=5%>0388</td>
    <td width=95%> [L] '#include "%s"' causes nesting to exceed 15 levels - program does not conform strictly to ISO:C99.</td>
  </tr>
  <tr>
    <td width=5%>0390</td>
    <td width=95%> [L] Number of members in 'struct' or 'union' exceeds 1023 - program does not conform strictly to ISO:C99.</td>
  </tr>
  <tr>
    <td width=5%>0391</td>
    <td width=95%> [L] Number of enumeration constants exceeds 1023 - program does not conform strictly to ISO:C99.</td>
  </tr>
  <tr>
    <td width=5%>0392</td>
    <td width=95%> [L] Nesting of 'struct' or 'union' types exceeds 63 - program does not conform strictly to ISO:C99.</td>
  </tr>
  <tr>
    <td width=5%>0581</td>
    <td width=95%> [I] Floating-point constant may be too small to be representable.</td>
  </tr>
  <tr>
    <td width=5%>0634</td>
    <td width=95%> [I] Bit-fields in this struct/union have not been declared explicitly as unsigned or signed.</td>
  </tr>
  <tr>
    <td width=5%>2850</td>
    <td width=95%> Constant: Implicit conversion to a signed integer type of insufficient size.</td>
  </tr>
  <tr>
    <td width=5%>2851</td>
    <td width=95%> Definite: Implicit conversion to a signed integer type of insufficient size.</td>
  </tr>
  <tr>
    <td width=5%>2852</td>
    <td width=95%> Apparent: Implicit conversion to a signed integer type of insufficient size.</td>
  </tr>
  <tr>
    <td width=5%>2855</td>
    <td width=95%> Constant: Casting to a signed integer type of insufficient size.</td>
  </tr>
  <tr>
    <td width=5%>2856</td>
    <td width=95%> Definite: Casting to a signed integer type of insufficient size.</td>
  </tr>
  <tr>
    <td width=5%>2857</td>
    <td width=95%> Apparent: Casting to a signed integer type of insufficient size.</td>
  </tr>
  <tr>
    <td width=5%>2860</td>
    <td width=95%> Constant: Implementation-defined value resulting from left shift operation on expression of signed type.</td>
  </tr>
  <tr>
    <td width=5%>2861</td>
    <td width=95%> Definite: Implementation-defined value resulting from left shift operation on expression of signed type.</td>
  </tr>
  <tr>
    <td width=5%>2862</td>
    <td width=95%> Apparent: Implementation-defined value resulting from left shift operation on expression of signed type.</td>
  </tr>
  <tr>
    <td width=5%>2895</td>
    <td width=95%> Constant: Negative value cast to an unsigned type.</td>
  </tr>
  <tr>
    <td width=5%>2896</td>
    <td width=95%> Definite: Negative value cast to an unsigned type.</td>
  </tr>
  <tr>
    <td width=5%>2897</td>
    <td width=95%> Apparent: Negative value cast to an unsigned type.</td>
  </tr>
  <tr>
    <td width=5%>3116</td>
    <td width=95%> Unrecognized #pragma arguments '%s' This #pragma directive has been ignored.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Dir-2.1</td>
    <td width=2%>Required</td>
    <td width=50%>All source files shall compile without any compilation errors</td>
    <td class="docCellBlue">Unassisted<br><br>
Remarks:<br>
Dedicated checks deployed in Jenkins.</td>
  </tr>
  <tr>                                           
    <td width=2%>Dir-3.1</td>
    <td width=2%>Required</td>
    <td width=50%>All code shall be traceable to documented requirements</td>
    <td class="docCellBlue">Unassisted<br><br>
Remarks:<br>
Limited management of requirements.</td>
  </tr>
  <tr>                                           
    <td width=2%>Dir-4.1</td>
    <td width=2%>Required</td>
    <td width=50%>Run-time failures shall be minimized</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>2791</td>
    <td width=95%> Definite: Right hand operand of shift operator is negative or too large.</td>
  </tr>
  <tr>
    <td width=5%>2792</td>
    <td width=95%> Apparent: Right hand operand of shift operator is negative or too large.</td>
  </tr>
  <tr>
    <td width=5%>2801</td>
    <td width=95%> Definite: Overflow in signed arithmetic operation.</td>
  </tr>
  <tr>
    <td width=5%>2802</td>
    <td width=95%> Apparent: Overflow in signed arithmetic operation.</td>
  </tr>
  <tr>
    <td width=5%>2811</td>
    <td width=95%> Definite: Dereference of NULL pointer.</td>
  </tr>
  <tr>
    <td width=5%>2812</td>
    <td width=95%> Apparent: Dereference of NULL pointer.</td>
  </tr>
  <tr>
    <td width=5%>2821</td>
    <td width=95%> Definite: Arithmetic operation on NULL pointer.</td>
  </tr>
  <tr>
    <td width=5%>2822</td>
    <td width=95%> Apparent: Arithmetic operation on NULL pointer.</td>
  </tr>
  <tr>
    <td width=5%>2831</td>
    <td width=95%> Definite: Division by zero.</td>
  </tr>
  <tr>
    <td width=5%>2832</td>
    <td width=95%> Apparent: Division by zero.</td>
  </tr>
  <tr>
    <td width=5%>2841</td>
    <td width=95%> Definite: Dereference of an invalid pointer value.</td>
  </tr>
  <tr>
    <td width=5%>2842</td>
    <td width=95%> Apparent: Dereference of an invalid pointer value.</td>
  </tr>
  <tr>
    <td width=5%>2845</td>
    <td width=95%> Constant: Maximum number of characters to be written is larger than the target buffer size.</td>
  </tr>
  <tr>
    <td width=5%>2846</td>
    <td width=95%> Definite: Maximum number of characters to be written is larger than the target buffer size.</td>
  </tr>
  <tr>
    <td width=5%>2847</td>
    <td width=95%> Apparent: Maximum number of characters to be written is larger than the target buffer size.</td>
  </tr>
  <tr>
    <td width=5%>2871</td>
    <td width=95%> Infinite loop identified.</td>
  </tr>
  <tr>
    <td width=5%>2872</td>
    <td width=95%> This loop, if entered, will never terminate.</td>
  </tr>
  <tr>
    <td width=5%>2877</td>
    <td width=95%> This loop will never be executed more than once.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Dir-4.10</td>
    <td width=2%>Required</td>
    <td width=50%>Precautions shall be taken in order to prevent the contents of a header file being included more then once</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0883</td>
    <td width=95%> Include file code is not protected against repeated inclusion</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Dir-4.11</td>
    <td width=2%>Required</td>
    <td width=50%>The validity of values passed to library functions shall be checked</td>
    <td class="docCellBlue">Unassisted<br><br>
Remarks:<br>
No automated check deployed.<br>
Manual checks done by developers.</td>
  </tr>
  <tr>                                           
    <td width=2%>Dir-4.12</td>
    <td width=2%>Required</td>
    <td width=50%>Dynamic memory allocation shall not be used</td>
    <td class="docCellBlue">Unassisted<br><br>
Remarks:<br>
No memory allocation functions (malloc(), calloc(), realloc()) being called in RFAL.</td>
  </tr>
  <tr>                                           
    <td width=2%>Dir-4.13</td>
    <td width=2%>Advisory</td>
    <td width=50%>Functions which are designed to provide operations on a resource should be called in an appropriate sequence</td>
    <td class="docCellBlue">Unassisted</td>
  </tr>
  <tr>                                           
    <td width=2%>Dir-4.14</td>
    <td width=2%>Required</td>
    <td width=50%>The validity of values received from external sources shall be checked</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>2956</td>
    <td width=95%> Definite: Using object '%s' with tainted value.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Dir-4.2</td>
    <td width=2%>Advisory</td>
    <td width=50%>All usage of assembly language should be documented</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>1003</td>
    <td width=95%> [E] '#%s' is a language extension for in-line assembler. All statements located between #asm and #endasm will be ignored.</td>
  </tr>
  <tr>
    <td width=5%>1006</td>
    <td width=95%> [E] This in-line assembler construct is a language extension. The code has been ignored.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Dir-4.3</td>
    <td width=2%>Required</td>
    <td width=50%>Assembly language shall be encapsulated and isolated</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3006</td>
    <td width=95%> This function contains a mixture of in-line assembler statements and C statements.</td>
  </tr>
  <tr>
    <td width=5%>3008</td>
    <td width=95%> This function contains a mixture of in-line assembler statements and C code.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Dir-4.4</td>
    <td width=2%>Advisory</td>
    <td width=50%>Sections of code should not be "commented out"</td>
    <td class="docCellBlue">Unassisted</td>
  </tr>
  <tr>                                           
    <td width=2%>Dir-4.5</td>
    <td width=2%>Advisory</td>
    <td width=50%>Identifiers in the same name space with overlapping visibility should be typographically unambiguous</td>
    <td class="docCellBlue">Unassisted</td>
  </tr>
  <tr>                                           
    <td width=2%>Dir-4.6</td>
    <td width=2%>Advisory</td>
    <td width=50%>typedefs that indicate size and signedness should be used in place of the basic numerical types</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>5209</td>
    <td width=95%> Use of basic type '%s'.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Dir-4.7</td>
    <td width=2%>Required</td>
    <td width=50%>If a function returns error information, then that error information shall be tested</td>
    <td class="docCellBlue">Unassisted<br><br>
Remarks:<br>
Dir-4.7 is similar to Rule-17.7 which is currently dismissed.<br>
This directive is consequently considered as disapplied.</td>
  </tr>
  <tr>                                           
    <td width=2%>Dir-4.8</td>
    <td width=2%>Advisory</td>
    <td width=50%>If a pointer to a structure or union is never dereferenced within a translation unit, then the implementation of the object should be hidden</td>
    <td class="docCellBlue">Unassisted</td>
  </tr>
  <tr>                                           
    <td width=2%>Dir-4.9</td>
    <td width=2%>Advisory</td>
    <td width=50%>A function should be used in preference to a function-like macro where they are interchangeable</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3453</td>
    <td width=95%> A function could probably be used instead of this function-like macro.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-1.1</td>
    <td width=2%>Required</td>
    <td width=50%>The program shall contain no violations of the standard C syntax and constraints, and shall not exceed the implementation's translation limits</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0232</td>
    <td width=95%> [C] Value of hex escape sequence is not representable in type 'unsigned char'.</td>
  </tr>
  <tr>
    <td width=5%>0233</td>
    <td width=95%> [C] Value of octal escape sequence is not representable in type 'unsigned char'.</td>
  </tr>
  <tr>
    <td width=5%>0244</td>
    <td width=95%> [C] Value of character constant is not representable in type 'int'.</td>
  </tr>
  <tr>
    <td width=5%>0268</td>
    <td width=95%> [S] Comment open at end of translation unit.</td>
  </tr>
  <tr>
    <td width=5%>0321</td>
    <td width=95%> [C] Declaration within 'for' statement defines an identifier '%s' which is not an object.</td>
  </tr>
  <tr>
    <td width=5%>0322</td>
    <td width=95%> [C] Illegal storage class specifier used in 'for' statement declaration.</td>
  </tr>
  <tr>
    <td width=5%>0338</td>
    <td width=95%> [C] Octal or hex escape sequence value is too large for 'unsigned char' or 'wchar_t' type.</td>
  </tr>
  <tr>
    <td width=5%>0422</td>
    <td width=95%> [C] Function call contains fewer arguments than prototype specifies.</td>
  </tr>
  <tr>
    <td width=5%>0423</td>
    <td width=95%> [C] Function call contains more arguments than prototype specifies.</td>
  </tr>
  <tr>
    <td width=5%>0426</td>
    <td width=95%> [C] Called function has incomplete return type.</td>
  </tr>
  <tr>
    <td width=5%>0427</td>
    <td width=95%> [C] Object identifier used as if it were a function or a function pointer identifier.</td>
  </tr>
  <tr>
    <td width=5%>0429</td>
    <td width=95%> [C] Function argument is not of arithmetic type.</td>
  </tr>
  <tr>
    <td width=5%>0430</td>
    <td width=95%> [C] Function argument is not of compatible 'struct'/'union' type.</td>
  </tr>
  <tr>
    <td width=5%>0431</td>
    <td width=95%> [C] Function argument points to a more heavily qualified type.</td>
  </tr>
  <tr>
    <td width=5%>0432</td>
    <td width=95%> [C] Function argument is not of compatible pointer type.</td>
  </tr>
  <tr>
    <td width=5%>0435</td>
    <td width=95%> [C] The 'struct'/'union' member '%s' does not exist.</td>
  </tr>
  <tr>
    <td width=5%>0436</td>
    <td width=95%> [C] Left operand of '.' must be a 'struct' or 'union' object.</td>
  </tr>
  <tr>
    <td width=5%>0437</td>
    <td width=95%> [C] Left operand of '->' must be a pointer to a 'struct' or 'union' object.</td>
  </tr>
  <tr>
    <td width=5%>0446</td>
    <td width=95%> [C] Operand of ++/-- must have scalar (arithmetic or pointer) type.</td>
  </tr>
  <tr>
    <td width=5%>0447</td>
    <td width=95%> [C] Operand of ++/-- must be a modifiable object.</td>
  </tr>
  <tr>
    <td width=5%>0448</td>
    <td width=95%> [C] Operand of ++/-- must not be a pointer to an object of unknown size.</td>
  </tr>
  <tr>
    <td width=5%>0449</td>
    <td width=95%> [C] Operand of ++/-- must not be a pointer to a function.</td>
  </tr>
  <tr>
    <td width=5%>0450</td>
    <td width=95%> [C] An expression of array type cannot be cast.</td>
  </tr>
  <tr>
    <td width=5%>0451</td>
    <td width=95%> [C] Subscripting requires a pointer (or array lvalue).</td>
  </tr>
  <tr>
    <td width=5%>0452</td>
    <td width=95%> [C] Cannot subscript a pointer to an object of unknown size.</td>
  </tr>
  <tr>
    <td width=5%>0453</td>
    <td width=95%> [C] An array subscript must have integral type.</td>
  </tr>
  <tr>
    <td width=5%>0454</td>
    <td width=95%> [C] The address-of operator '&' cannot be applied to an object declared with 'register'.</td>
  </tr>
  <tr>
    <td width=5%>0456</td>
    <td width=95%> [C] This expression does not have an address - '&' may only be applied to an lvalue or a function designator.</td>
  </tr>
  <tr>
    <td width=5%>0457</td>
    <td width=95%> [C] The address-of operator '&' cannot be applied to a bit-field.</td>
  </tr>
  <tr>
    <td width=5%>0458</td>
    <td width=95%> [C] Indirection operator '*' requires operand of pointer type.</td>
  </tr>
  <tr>
    <td width=5%>0460</td>
    <td width=95%> [C] The keyword static is used in the declaration of the index of an array which is not a function parameter.</td>
  </tr>
  <tr>
    <td width=5%>0461</td>
    <td width=95%> [C] The keyword static is used in the declaration of an inner index of a multi-dimensional array.</td>
  </tr>
  <tr>
    <td width=5%>0462</td>
    <td width=95%> [C] A type qualifier (const, volatile or restrict) is used in the declaration of the index of an array which is not a function parameter.</td>
  </tr>
  <tr>
    <td width=5%>0463</td>
    <td width=95%> [C] A type qualifier (const, volatile or restrict) is used in the declaration of an inner index of a multi-dimensional array.</td>
  </tr>
  <tr>
    <td width=5%>0466</td>
    <td width=95%> [C] Unary '+' requires arithmetic operand.</td>
  </tr>
  <tr>
    <td width=5%>0467</td>
    <td width=95%> [C] Operand of '!' must have scalar (arithmetic or pointer) type.</td>
  </tr>
  <tr>
    <td width=5%>0468</td>
    <td width=95%> [C] Unary '-' requires arithmetic operand.</td>
  </tr>
  <tr>
    <td width=5%>0469</td>
    <td width=95%> [C] Bitwise not '~' requires integral operand.</td>
  </tr>
  <tr>
    <td width=5%>0476</td>
    <td width=95%> [C] 'sizeof' cannot be applied to a bit-field.</td>
  </tr>
  <tr>
    <td width=5%>0477</td>
    <td width=95%> [C] 'sizeof' cannot be applied to a function.</td>
  </tr>
  <tr>
    <td width=5%>0478</td>
    <td width=95%> [C] 'sizeof' cannot be applied to an object of unknown size.</td>
  </tr>
  <tr>
    <td width=5%>0481</td>
    <td width=95%> [C] Only scalar expressions may be cast to other types.</td>
  </tr>
  <tr>
    <td width=5%>0482</td>
    <td width=95%> [C] Expressions may only be cast to 'void' or scalar types.</td>
  </tr>
  <tr>
    <td width=5%>0483</td>
    <td width=95%> [C] A pointer to an object of unknown size cannot be the operand of an addition operator.</td>
  </tr>
  <tr>
    <td width=5%>0484</td>
    <td width=95%> [C] A pointer to an object of unknown size cannot be the operand of a subtraction operator.</td>
  </tr>
  <tr>
    <td width=5%>0485</td>
    <td width=95%> [C] Only integral expressions may be added to pointers.</td>
  </tr>
  <tr>
    <td width=5%>0486</td>
    <td width=95%> [C] Only integral expressions and compatible pointers may be subtracted from pointers.</td>
  </tr>
  <tr>
    <td width=5%>0487</td>
    <td width=95%> [C] If two pointers are subtracted, they must be pointers that address compatible types.</td>
  </tr>
  <tr>
    <td width=5%>0493</td>
    <td width=95%> [C] Type of left operand is not compatible with this operator.</td>
  </tr>
  <tr>
    <td width=5%>0494</td>
    <td width=95%> [C] Type of right operand is not compatible with this operator.</td>
  </tr>
  <tr>
    <td width=5%>0495</td>
    <td width=95%> [C] Left operand of '%', '<<', '>>', '&', '^' or '|' must have integral type.</td>
  </tr>
  <tr>
    <td width=5%>0496</td>
    <td width=95%> [C] Right operand of '%', '<<', '>>', '&', '^' or '|' must have integral type.</td>
  </tr>
  <tr>
    <td width=5%>0513</td>
    <td width=95%> [C] Relational operator used to compare pointers to incompatible types.</td>
  </tr>
  <tr>
    <td width=5%>0514</td>
    <td width=95%> [C] Relational operator used to compare a pointer with an incompatible operand.</td>
  </tr>
  <tr>
    <td width=5%>0515</td>
    <td width=95%> [C] Equality operator used to compare a pointer with an incompatible operand.</td>
  </tr>
  <tr>
    <td width=5%>0536</td>
    <td width=95%> [C] First operand of '&&', '||' or '?' must have scalar (arithmetic or pointer) type.</td>
  </tr>
  <tr>
    <td width=5%>0537</td>
    <td width=95%> [C] Second operand of '&&' or '||' must have scalar (arithmetic or pointer) type.</td>
  </tr>
  <tr>
    <td width=5%>0540</td>
    <td width=95%> [C] 2nd and 3rd operands of conditional operator '?' must have compatible types.</td>
  </tr>
  <tr>
    <td width=5%>0541</td>
    <td width=95%> [C] Argument no. %s does not have object type.</td>
  </tr>
  <tr>
    <td width=5%>0542</td>
    <td width=95%> [C] Controlling expression must have scalar (arithmetic or pointer) type.</td>
  </tr>
  <tr>
    <td width=5%>0546</td>
    <td width=95%> [C] 'enum %s' has unknown content. Use of an enum tag with undefined content is not permitted.</td>
  </tr>
  <tr>
    <td width=5%>0547</td>
    <td width=95%> [C] This declaration of tag '%s' conflicts with a previous declaration.</td>
  </tr>
  <tr>
    <td width=5%>0550</td>
    <td width=95%> [C] Left operand of '+=' or '-=' is a pointer to an object of unknown size.</td>
  </tr>
  <tr>
    <td width=5%>0554</td>
    <td width=95%> [C] 'static %s()' has been declared and called but no definition has been given.</td>
  </tr>
  <tr>
    <td width=5%>0555</td>
    <td width=95%> [C] Invalid assignment to object of void type or array type.</td>
  </tr>
  <tr>
    <td width=5%>0556</td>
    <td width=95%> [C] Left operand of assignment must be a modifiable object.</td>
  </tr>
  <tr>
    <td width=5%>0557</td>
    <td width=95%> [C] Right operand of assignment is not of arithmetic type.</td>
  </tr>
  <tr>
    <td width=5%>0558</td>
    <td width=95%> [C] Right operand of '+=' or '-=' must have integral type when left operand is a pointer.</td>
  </tr>
  <tr>
    <td width=5%>0559</td>
    <td width=95%> [C] Right operand of '<<=', '>>=', '&=', '|=', '^=' or '%=' must have integral type.</td>
  </tr>
  <tr>
    <td width=5%>0560</td>
    <td width=95%> [C] Left operand of '<<=', '>>=', '&=', '|=', '^=' or '%=' must have integral type.</td>
  </tr>
  <tr>
    <td width=5%>0561</td>
    <td width=95%> [C] Right operand of assignment is not of compatible 'struct'/'union' type.</td>
  </tr>
  <tr>
    <td width=5%>0562</td>
    <td width=95%> [C] Right operand of assignment points to a more heavily qualified type.</td>
  </tr>
  <tr>
    <td width=5%>0563</td>
    <td width=95%> [C] Right operand of assignment is not of compatible pointer type.</td>
  </tr>
  <tr>
    <td width=5%>0564</td>
    <td width=95%> [C] Left operand of assignment must be an lvalue (it must designate an object).</td>
  </tr>
  <tr>
    <td width=5%>0565</td>
    <td width=95%> [C] Left operand of '+=' or '-=' must be of arithmetic or pointer to object type.</td>
  </tr>
  <tr>
    <td width=5%>0580</td>
    <td width=95%> [C] Constant is too large to be representable.</td>
  </tr>
  <tr>
    <td width=5%>0588</td>
    <td width=95%> [C] Width of bit-field must be an integral constant expression.</td>
  </tr>
  <tr>
    <td width=5%>0589</td>
    <td width=95%> [C] Enumeration constant must be an integral constant expression.</td>
  </tr>
  <tr>
    <td width=5%>0590</td>
    <td width=95%> [C] Array bound must be an integral constant expression.</td>
  </tr>
  <tr>
    <td width=5%>0591</td>
    <td width=95%> [C] A 'case' label must be an integral constant expression.</td>
  </tr>
  <tr>
    <td width=5%>0605</td>
    <td width=95%> [C] A declaration must declare a tag or an identifier.</td>
  </tr>
  <tr>
    <td width=5%>0616</td>
    <td width=95%> [C] Illegal combination of type specifiers or storage class specifiers.</td>
  </tr>
  <tr>
    <td width=5%>0619</td>
    <td width=95%> [C] The identifier '%s' has already been defined in the current scope within the ordinary identifier namespace.</td>
  </tr>
  <tr>
    <td width=5%>0620</td>
    <td width=95%> [C] Cannot initialize '%s' because it has unknown size.</td>
  </tr>
  <tr>
    <td width=5%>0621</td>
    <td width=95%> [C] The struct/union '%s' cannot be initialized because it has unknown size.</td>
  </tr>
  <tr>
    <td width=5%>0622</td>
    <td width=95%> [C] The identifier '%s' has been declared both with and without linkage in the same scope.</td>
  </tr>
  <tr>
    <td width=5%>0627</td>
    <td width=95%> [C] '%s' has different type to previous declaration in the same scope.</td>
  </tr>
  <tr>
    <td width=5%>0628</td>
    <td width=95%> [C] '%s' has different type to previous declaration at wider scope.</td>
  </tr>
  <tr>
    <td width=5%>0629</td>
    <td width=95%> [C] More than one definition of '%s' (with internal linkage).</td>
  </tr>
  <tr>
    <td width=5%>0631</td>
    <td width=95%> [C] More than one declaration of '%s' (with no linkage).</td>
  </tr>
  <tr>
    <td width=5%>0638</td>
    <td width=95%> [C] Duplicate member name '%s' in 'struct' or 'union'.</td>
  </tr>
  <tr>
    <td width=5%>0640</td>
    <td width=95%> [C] '%s' in 'struct' or 'union' type may not have 'void' type.</td>
  </tr>
  <tr>
    <td width=5%>0641</td>
    <td width=95%> [C] '%s' in 'struct' or 'union' type may not have function type.</td>
  </tr>
  <tr>
    <td width=5%>0642</td>
    <td width=95%> [C] '%s' in 'struct' or 'union' type may not be an array of unknown size.</td>
  </tr>
  <tr>
    <td width=5%>0643</td>
    <td width=95%> [C] '%s' in 'struct' or 'union' type may not be a 'struct' or 'union' with unknown content.</td>
  </tr>
  <tr>
    <td width=5%>0644</td>
    <td width=95%> [C] Width of bit-field must be no bigger than the width of an 'int'.</td>
  </tr>
  <tr>
    <td width=5%>0645</td>
    <td width=95%> [C] A zero width bit-field cannot be given a name.</td>
  </tr>
  <tr>
    <td width=5%>0646</td>
    <td width=95%> [C] Enumeration constants must have values representable as 'int's.</td>
  </tr>
  <tr>
    <td width=5%>0649</td>
    <td width=95%> [C] K&R style declaration of parameters is not legal after a function header that includes a parameter list.</td>
  </tr>
  <tr>
    <td width=5%>0650</td>
    <td width=95%> [C] Illegal storage class specifier on named function parameter.</td>
  </tr>
  <tr>
    <td width=5%>0651</td>
    <td width=95%> [C] Missing type specifiers in function declaration.</td>
  </tr>
  <tr>
    <td width=5%>0653</td>
    <td width=95%> [C] Duplicate definition of 'struct', 'union' or 'enum' tag '%s'.</td>
  </tr>
  <tr>
    <td width=5%>0655</td>
    <td width=95%> [C] Illegal storage class specifier on unnamed function parameter.</td>
  </tr>
  <tr>
    <td width=5%>0656</td>
    <td width=95%> [C] Function return type cannot be function or array type, or an incomplete struct/union (for function definition).</td>
  </tr>
  <tr>
    <td width=5%>0657</td>
    <td width=95%> [C] Unnamed parameter specified in function definition.</td>
  </tr>
  <tr>
    <td width=5%>0659</td>
    <td width=95%> [C] The identifier '%s' was not given in the parameter list.</td>
  </tr>
  <tr>
    <td width=5%>0664</td>
    <td width=95%> [C] Parameter specified with type 'void'.</td>
  </tr>
  <tr>
    <td width=5%>0665</td>
    <td width=95%> [C] Two parameters have been declared with the same name '%s'.</td>
  </tr>
  <tr>
    <td width=5%>0669</td>
    <td width=95%> [C] The restrict qualifier can only be applied to pointer types derived from object or incomplete types.</td>
  </tr>
  <tr>
    <td width=5%>0671</td>
    <td width=95%> [C] Initializer for object of arithmetic type is not of arithmetic type.</td>
  </tr>
  <tr>
    <td width=5%>0673</td>
    <td width=95%> [C] Initializer points to a more heavily qualified type.</td>
  </tr>
  <tr>
    <td width=5%>0674</td>
    <td width=95%> [C] Initializer for pointer is of incompatible type.</td>
  </tr>
  <tr>
    <td width=5%>0675</td>
    <td width=95%> [C] Initializer is not of compatible 'struct'/'union' type.</td>
  </tr>
  <tr>
    <td width=5%>0677</td>
    <td width=95%> [C] Array size is negative, or unrepresentable.</td>
  </tr>
  <tr>
    <td width=5%>0682</td>
    <td width=95%> [C] Initializer for object of a character type is a string literal.</td>
  </tr>
  <tr>
    <td width=5%>0683</td>
    <td width=95%> [C] Initializer for object of a character type is a wide string literal.</td>
  </tr>
  <tr>
    <td width=5%>0684</td>
    <td width=95%> [C] Too many initializers.</td>
  </tr>
  <tr>
    <td width=5%>0685</td>
    <td width=95%> [C] Initializer for any object with static storage duration must be a constant expression.</td>
  </tr>
  <tr>
    <td width=5%>0690</td>
    <td width=95%> [C] String literal contains too many characters to initialize object.</td>
  </tr>
  <tr>
    <td width=5%>0698</td>
    <td width=95%> [C] String literal used to initialize an object of incompatible type.</td>
  </tr>
  <tr>
    <td width=5%>0699</td>
    <td width=95%> [C] String literal used to initialize a pointer of incompatible type.</td>
  </tr>
  <tr>
    <td width=5%>0708</td>
    <td width=95%> [C] No definition found for the label '%s' in this function.</td>
  </tr>
  <tr>
    <td width=5%>0709</td>
    <td width=95%> [C] Initialization of locally declared 'extern %s' is illegal.</td>
  </tr>
  <tr>
    <td width=5%>0736</td>
    <td width=95%> [C] 'case' label does not have unique value within this 'switch' statement.</td>
  </tr>
  <tr>
    <td width=5%>0737</td>
    <td width=95%> [C] More than one 'default' label found in 'switch' statement.</td>
  </tr>
  <tr>
    <td width=5%>0738</td>
    <td width=95%> [C] Controlling expression in a 'switch' statement must have integral type.</td>
  </tr>
  <tr>
    <td width=5%>0746</td>
    <td width=95%> [C] 'return exp;' found in '%s()' whose return type is 'void'.</td>
  </tr>
  <tr>
    <td width=5%>0747</td>
    <td width=95%> [C] 'return exp;' found in '%s()' whose return type is qualified 'void'.</td>
  </tr>
  <tr>
    <td width=5%>0755</td>
    <td width=95%> [C] 'return' expression is not of arithmetic type.</td>
  </tr>
  <tr>
    <td width=5%>0756</td>
    <td width=95%> [C] 'return' expression is not of compatible 'struct'/'union' type.</td>
  </tr>
  <tr>
    <td width=5%>0757</td>
    <td width=95%> [C] 'return' expression points to a more heavily qualified type.</td>
  </tr>
  <tr>
    <td width=5%>0758</td>
    <td width=95%> [C] 'return' expression is not of compatible pointer type.</td>
  </tr>
  <tr>
    <td width=5%>0766</td>
    <td width=95%> [C] 'continue' statement found outside an iteration statement.</td>
  </tr>
  <tr>
    <td width=5%>0767</td>
    <td width=95%> [C] 'break' statement found outside a 'switch' or iteration statement.</td>
  </tr>
  <tr>
    <td width=5%>0768</td>
    <td width=95%> [C] 'case' or 'default' found outside a 'switch' statement.</td>
  </tr>
  <tr>
    <td width=5%>0774</td>
    <td width=95%> [C] 'auto' may not be specified on global declaration of '%s'.</td>
  </tr>
  <tr>
    <td width=5%>0775</td>
    <td width=95%> [C] 'register' may not be specified on global declaration of '%s'.</td>
  </tr>
  <tr>
    <td width=5%>0801</td>
    <td width=95%> [C] The '##' operator may not be the first token in a macro replacement list.</td>
  </tr>
  <tr>
    <td width=5%>0802</td>
    <td width=95%> [C] The '##' operator may not be the last token in a macro replacement list.</td>
  </tr>
  <tr>
    <td width=5%>0803</td>
    <td width=95%> [C] The '#' operator may only appear before a macro parameter.</td>
  </tr>
  <tr>
    <td width=5%>0804</td>
    <td width=95%> [C] Macro parameter '%s' is not unique.</td>
  </tr>
  <tr>
    <td width=5%>0811</td>
    <td width=95%> [C] The glue operator '##' may only appear in a '#define' preprocessing directive.</td>
  </tr>
  <tr>
    <td width=5%>0812</td>
    <td width=95%> [C] Header name token '<text>' found outside '#include' preprocessing directive.</td>
  </tr>
  <tr>
    <td width=5%>0817</td>
    <td width=95%> [S] Closing quote or bracket '>' missing from include filename.</td>
  </tr>
  <tr>
    <td width=5%>0818</td>
    <td width=95%> [Q] Cannot find '%s' - Perhaps the appropriate search path was not given ?</td>
  </tr>
  <tr>
    <td width=5%>0821</td>
    <td width=95%> [C] '#include' does not identify a header or source file that can be processed.</td>
  </tr>
  <tr>
    <td width=5%>0834</td>
    <td width=95%> [C] Function-like macro '%s()' is being redefined as an object-like macro.</td>
  </tr>
  <tr>
    <td width=5%>0835</td>
    <td width=95%> [C] Macro '%s' is being redefined with different parameter names.</td>
  </tr>
  <tr>
    <td width=5%>0844</td>
    <td width=95%> [C] Macro '%s' is being redefined with a different replacement list.</td>
  </tr>
  <tr>
    <td width=5%>0845</td>
    <td width=95%> [C] Object-like macro '%s' is being redefined as a function-like macro.</td>
  </tr>
  <tr>
    <td width=5%>0851</td>
    <td width=95%> [C] More arguments in macro call than specified in definition.</td>
  </tr>
  <tr>
    <td width=5%>0852</td>
    <td width=95%> [S] Unable to find the ')' that marks the end of the macro call.</td>
  </tr>
  <tr>
    <td width=5%>0866</td>
    <td width=95%> [C] The string literal in a '#line' directive cannot be a 'wide string literal'.</td>
  </tr>
  <tr>
    <td width=5%>0873</td>
    <td width=95%> [C] Preprocessing token cannot be converted to an actual token.</td>
  </tr>
  <tr>
    <td width=5%>0877</td>
    <td width=95%> [C] '#if' and '#elif' expressions may contain only integral constants.</td>
  </tr>
  <tr>
    <td width=5%>0940</td>
    <td width=95%> [C] Illegal usage of a variably modified type.</td>
  </tr>
  <tr>
    <td width=5%>0941</td>
    <td width=95%> [C] A variable length array may not be initialized.</td>
  </tr>
  <tr>
    <td width=5%>0943</td>
    <td width=95%> [C] Jump to label '%s' is a jump into the scope of an identifier with variably modified type.</td>
  </tr>
  <tr>
    <td width=5%>0944</td>
    <td width=95%> [C] The label '%s' is inside the scope of an identifier with variably modified type.</td>
  </tr>
  <tr>
    <td width=5%>1023</td>
    <td width=95%> [C] Using '__alignof__' on function types is illegal.</td>
  </tr>
  <tr>
    <td width=5%>1024</td>
    <td width=95%> [C] Using '__alignof__' on incomplete types is illegal.</td>
  </tr>
  <tr>
    <td width=5%>1025</td>
    <td width=95%> [C] Using '__alignof__' on bit-fields is illegal.</td>
  </tr>
  <tr>
    <td width=5%>1033</td>
    <td width=95%> [C] The identifier __VA_ARGS__ may only be used in the replacement list of a variadic macro.</td>
  </tr>
  <tr>
    <td width=5%>1047</td>
    <td width=95%> [C] Function is being declared with default argument syntax after a previous call to the function. This is not allowed.</td>
  </tr>
  <tr>
    <td width=5%>1048</td>
    <td width=95%> [C] Default argument values are missing for some parameters in this function declaration. This is not allowed.</td>
  </tr>
  <tr>
    <td width=5%>1050</td>
    <td width=95%> [C] Nested functions cannot be 'extern' or 'static'.</td>
  </tr>
  <tr>
    <td width=5%>1061</td>
    <td width=95%> [C] Structure '%1s' with flexible array member '%2s' cannot be used in the declaration of structure member '%3s'.</td>
  </tr>
  <tr>
    <td width=5%>1062</td>
    <td width=95%> [C] Structure '%1s' with flexible array member '%2s' cannot be used in the declaration of array elements.</td>
  </tr>
  <tr>
    <td width=5%>3236</td>
    <td width=95%> [C] 'inline' may not be applied to function 'main'.</td>
  </tr>
  <tr>
    <td width=5%>3237</td>
    <td width=95%> [C] inline function '%1s' has external linkage and is defining an object, '%2s', with static storage duration.</td>
  </tr>
  <tr>
    <td width=5%>3238</td>
    <td width=95%> [C] inline function '%1s' has external linkage and is referring to an object, '%2s', with internal linkage.</td>
  </tr>
  <tr>
    <td width=5%>3244</td>
    <td width=95%> [C] 'inline' may only be used in the declaration of a function identifier.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-1.2</td>
    <td width=2%>Advisory</td>
    <td width=50%>Language extensions should not be used</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0240</td>
    <td width=95%> [E] This file contains the control-M character at the end of a line.</td>
  </tr>
  <tr>
    <td width=5%>0241</td>
    <td width=95%> [E] This file contains the control-Z character - was this transferred from a PC?</td>
  </tr>
  <tr>
    <td width=5%>0246</td>
    <td width=95%> [E] Binary integer constants are a language extension.</td>
  </tr>
  <tr>
    <td width=5%>0551</td>
    <td width=95%> [E] Cast may not operate on the left operand of the assignment operator.</td>
  </tr>
  <tr>
    <td width=5%>0601</td>
    <td width=95%> [E] Function 'main()' is not of type 'int (void)' or 'int (int, char *[])'.</td>
  </tr>
  <tr>
    <td width=5%>0633</td>
    <td width=95%> [E] Empty structures and unions are a language extension.</td>
  </tr>
  <tr>
    <td width=5%>0635</td>
    <td width=95%> [E] Bit-fields in this struct/union have been declared with types other than int, signed int, unsigned int or _Bool.</td>
  </tr>
  <tr>
    <td width=5%>0660</td>
    <td width=95%> [E] Defining an unnamed member in a struct or union. This is a language extension.</td>
  </tr>
  <tr>
    <td width=5%>0662</td>
    <td width=95%> [E] Accessing a member of an unnamed struct or union member in this way is a language extension.</td>
  </tr>
  <tr>
    <td width=5%>0830</td>
    <td width=95%> [E] Unrecognized text encountered after a preprocessing directive.</td>
  </tr>
  <tr>
    <td width=5%>0831</td>
    <td width=95%> [E] Use of '\\' in this '#include' line is a PC extension - this usage is non-portable.</td>
  </tr>
  <tr>
    <td width=5%>0840</td>
    <td width=95%> [E] Extra tokens at end of #include directive.</td>
  </tr>
  <tr>
    <td width=5%>0883</td>
    <td width=95%> Include file code is not protected against repeated inclusion</td>
  </tr>
  <tr>
    <td width=5%>0899</td>
    <td width=95%> [E] Unrecognized preprocessing directive has been ignored - assumed to be a language extension.</td>
  </tr>
  <tr>
    <td width=5%>0981</td>
    <td width=95%> [E] Redundant semicolon in 'struct' or 'union' member declaration list is a language extension.</td>
  </tr>
  <tr>
    <td width=5%>1001</td>
    <td width=95%> [E] '#include %s' is a VMS extension.</td>
  </tr>
  <tr>
    <td width=5%>1002</td>
    <td width=95%> [E] '%s' is not a legal identifier in ISO C.</td>
  </tr>
  <tr>
    <td width=5%>1003</td>
    <td width=95%> [E] '#%s' is a language extension for in-line assembler. All statements located between #asm and #endasm will be ignored.</td>
  </tr>
  <tr>
    <td width=5%>1006</td>
    <td width=95%> [E] This in-line assembler construct is a language extension. The code has been ignored.</td>
  </tr>
  <tr>
    <td width=5%>1008</td>
    <td width=95%> [E] '#%s' is not a legal ISO C preprocessing directive.</td>
  </tr>
  <tr>
    <td width=5%>1012</td>
    <td width=95%> [E] Use of a C++ reference type ('type &') will be treated as a language extension.</td>
  </tr>
  <tr>
    <td width=5%>1014</td>
    <td width=95%> [E] Non-standard type specifier - this will be treated as a language extension.</td>
  </tr>
  <tr>
    <td width=5%>1015</td>
    <td width=95%> [E] '%s' is not a legal keyword in ISO C - this will be treated as a language extension.</td>
  </tr>
  <tr>
    <td width=5%>1019</td>
    <td width=95%> [E] '@ address' is not supported in ISO C - this will be treated as a language extension.</td>
  </tr>
  <tr>
    <td width=5%>1020</td>
    <td width=95%> [E] '__typeof__' is not supported in ISO C, and is treated as a language extension.</td>
  </tr>
  <tr>
    <td width=5%>1021</td>
    <td width=95%> [E] A statement expression is not supported in ISO C, and is treated as a language extension.</td>
  </tr>
  <tr>
    <td width=5%>1022</td>
    <td width=95%> [E] '__alignof__' is not supported in ISO C, and is treated as a language extension.</td>
  </tr>
  <tr>
    <td width=5%>1026</td>
    <td width=95%> [E] The indicated @word construct has been ignored.</td>
  </tr>
  <tr>
    <td width=5%>1028</td>
    <td width=95%> [E] Use of the sizeof operator in a preprocessing directive is a language extension.</td>
  </tr>
  <tr>
    <td width=5%>1029</td>
    <td width=95%> [E] Whitespace encountered between backslash and new-line has been ignored.</td>
  </tr>
  <tr>
    <td width=5%>1034</td>
    <td width=95%> [E] Macro defined with named variable argument list. This is a language extension.</td>
  </tr>
  <tr>
    <td width=5%>1035</td>
    <td width=95%> [E] No macro arguments supplied for variable argument list. This is a language extension.</td>
  </tr>
  <tr>
    <td width=5%>1036</td>
    <td width=95%> [E] Comma before ## ignored in expansion of variadic macro. This is a language extension.</td>
  </tr>
  <tr>
    <td width=5%>1037</td>
    <td width=95%> [E] Arrays of length zero are a language extension.</td>
  </tr>
  <tr>
    <td width=5%>1038</td>
    <td width=95%> [E] The sequence ", ##__VA_ARGS__" is a language extension.</td>
  </tr>
  <tr>
    <td width=5%>1039</td>
    <td width=95%> [E] Treating array of length one as potentially flexible member.</td>
  </tr>
  <tr>
    <td width=5%>1041</td>
    <td width=95%> [E] Empty aggregate initializers are a language extension.</td>
  </tr>
  <tr>
    <td width=5%>1042</td>
    <td width=95%> [E] Using I64 or UI64 as an integer constant suffix. This is a language extension.</td>
  </tr>
  <tr>
    <td width=5%>1043</td>
    <td width=95%> [E] Defining an anonymous union object. This is a language extension.</td>
  </tr>
  <tr>
    <td width=5%>1044</td>
    <td width=95%> [E] Defining an anonymous struct object. This is a language extension.</td>
  </tr>
  <tr>
    <td width=5%>1045</td>
    <td width=95%> [E] Use of the #include_next preprocessing directive is a language extension.</td>
  </tr>
  <tr>
    <td width=5%>1046</td>
    <td width=95%> [E] Function is being declared with default argument syntax. This is a language extension.</td>
  </tr>
  <tr>
    <td width=5%>1049</td>
    <td width=95%> [E] Nested functions are a language extension.</td>
  </tr>
  <tr>
    <td width=5%>3445</td>
    <td width=95%> [E] Conditional expression with middle operand omitted is a language extension.</td>
  </tr>
  <tr>
    <td width=5%>3664</td>
    <td width=95%> [E] Using a dot operator to access an individual bit is a language extension.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-1.3</td>
    <td width=2%>Required</td>
    <td width=50%>There shall be no occurrence of undefined or critical unspecified behaviour</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0160</td>
    <td width=95%> [U] Using unsupported conversion specifier number %s.</td>
  </tr>
  <tr>
    <td width=5%>0161</td>
    <td width=95%> [U] Unknown length modifier used with 'i' or 'd' conversion specifier, number %s.</td>
  </tr>
  <tr>
    <td width=5%>0162</td>
    <td width=95%> [U] Unknown length modifier used with 'o' conversion specifier, number %s.</td>
  </tr>
  <tr>
    <td width=5%>0163</td>
    <td width=95%> [U] Unknown length modifier used with 'u' conversion specifier, number %s.</td>
  </tr>
  <tr>
    <td width=5%>0164</td>
    <td width=95%> [U] Unknown length modifier used with 'x' conversion specifier, number %s.</td>
  </tr>
  <tr>
    <td width=5%>0165</td>
    <td width=95%> [U] Unknown length modifier used with 'X' conversion specifier, number %s.</td>
  </tr>
  <tr>
    <td width=5%>0166</td>
    <td width=95%> [U] Unknown length modifier used with 'f' conversion specifier, number %s.</td>
  </tr>
  <tr>
    <td width=5%>0167</td>
    <td width=95%> [U] Unknown length modifier used with 'e' conversion specifier, number %s.</td>
  </tr>
  <tr>
    <td width=5%>0168</td>
    <td width=95%> [U] Unknown length modifier used with 'E' conversion specifier, number %s.</td>
  </tr>
  <tr>
    <td width=5%>0169</td>
    <td width=95%> [U] Unknown length modifier used with 'g' conversion specifier, number %s.</td>
  </tr>
  <tr>
    <td width=5%>0170</td>
    <td width=95%> [U] Unknown length modifier used with 'G' conversion specifier, number %s.</td>
  </tr>
  <tr>
    <td width=5%>0171</td>
    <td width=95%> [U] Unknown length modifier used with 'c' conversion specifier, number %s.</td>
  </tr>
  <tr>
    <td width=5%>0172</td>
    <td width=95%> [U] Unknown length modifier used with '%%' conversion specifier, number %s.</td>
  </tr>
  <tr>
    <td width=5%>0173</td>
    <td width=95%> [U] Unknown length modifier used with 's' conversion specifier, number %s.</td>
  </tr>
  <tr>
    <td width=5%>0174</td>
    <td width=95%> [U] Unknown length modifier used with 'n' conversion specifier, number %s.</td>
  </tr>
  <tr>
    <td width=5%>0175</td>
    <td width=95%> [U] Unknown length modifier used with 'p' conversion specifier, number %s.</td>
  </tr>
  <tr>
    <td width=5%>0176</td>
    <td width=95%> [U] Incomplete conversion specifier, number %s.</td>
  </tr>
  <tr>
    <td width=5%>0177</td>
    <td width=95%> [U] Field width of format conversion specifier exceeds 509 characters.</td>
  </tr>
  <tr>
    <td width=5%>0178</td>
    <td width=95%> [U] Precision of format conversion specifier exceeds 509 characters.</td>
  </tr>
  <tr>
    <td width=5%>0179</td>
    <td width=95%> [U] Argument type does not match conversion specifier number %s.</td>
  </tr>
  <tr>
    <td width=5%>0184</td>
    <td width=95%> [U] Insufficient arguments to satisfy conversion specifier, number %s.</td>
  </tr>
  <tr>
    <td width=5%>0185</td>
    <td width=95%> [U] Call contains more arguments than conversion specifiers.</td>
  </tr>
  <tr>
    <td width=5%>0186</td>
    <td width=95%> [U] A call to this function must include at least one argument.</td>
  </tr>
  <tr>
    <td width=5%>0190</td>
    <td width=95%> [U] Using unsupported conversion specifier number %s.</td>
  </tr>
  <tr>
    <td width=5%>0191</td>
    <td width=95%> [U] Unknown length modifier used with 'd/i/n' conversion specifier, number %s.</td>
  </tr>
  <tr>
    <td width=5%>0192</td>
    <td width=95%> [U] Unknown length modifier used with 'o' conversion specifier, number %s.</td>
  </tr>
  <tr>
    <td width=5%>0193</td>
    <td width=95%> [U] Unknown length modifier used with 'u' conversion specifier, number %s.</td>
  </tr>
  <tr>
    <td width=5%>0194</td>
    <td width=95%> [U] Unknown length modifier used with 'x/X' conversion specifier, number %s.</td>
  </tr>
  <tr>
    <td width=5%>0195</td>
    <td width=95%> [U] Unknown length modifier used with 'e/E/f/F/g/G' conversion specifier, number %s.</td>
  </tr>
  <tr>
    <td width=5%>0196</td>
    <td width=95%> [U] Unknown length modifier used with 's' conversion specifier, number %s.</td>
  </tr>
  <tr>
    <td width=5%>0197</td>
    <td width=95%> [U] Unknown length modifier used with 'p' conversion specifier, number %s.</td>
  </tr>
  <tr>
    <td width=5%>0198</td>
    <td width=95%> [U] Unknown length modifier used with '%%' conversion specifier, number %s.</td>
  </tr>
  <tr>
    <td width=5%>0199</td>
    <td width=95%> [U] Unknown length modifier used with '[' conversion specifier, number %s.</td>
  </tr>
  <tr>
    <td width=5%>0200</td>
    <td width=95%> [U] Unknown length modifier used with 'c' conversion specifier, number %s.</td>
  </tr>
  <tr>
    <td width=5%>0201</td>
    <td width=95%> [U] Incomplete conversion specifier, number %s.</td>
  </tr>
  <tr>
    <td width=5%>0203</td>
    <td width=95%> [U] Value of character prior to '-' in '[]' is greater than following character.</td>
  </tr>
  <tr>
    <td width=5%>0204</td>
    <td width=95%> [U] Field width of format conversion specifier exceeds 509 characters.</td>
  </tr>
  <tr>
    <td width=5%>0206</td>
    <td width=95%> [U] Argument type does not match conversion specifier number %s.</td>
  </tr>
  <tr>
    <td width=5%>0207</td>
    <td width=95%> [U] 'scanf' expects address of objects being stored into.</td>
  </tr>
  <tr>
    <td width=5%>0208</td>
    <td width=95%> [U] Same character occurs in scanset more than once.</td>
  </tr>
  <tr>
    <td width=5%>0235</td>
    <td width=95%> [U] Unknown escape sequence.</td>
  </tr>
  <tr>
    <td width=5%>0275</td>
    <td width=95%> [U] Floating value is out of range for conversion to destination type.</td>
  </tr>
  <tr>
    <td width=5%>0301</td>
    <td width=95%> [u] Cast between a pointer to object and a floating type.</td>
  </tr>
  <tr>
    <td width=5%>0302</td>
    <td width=95%> [u] Cast between a pointer to function and a floating type.</td>
  </tr>
  <tr>
    <td width=5%>0304</td>
    <td width=95%> [U] The address of an array declared 'register' may not be computed.</td>
  </tr>
  <tr>
    <td width=5%>0307</td>
    <td width=95%> [u] Cast between a pointer to object and a pointer to function.</td>
  </tr>
  <tr>
    <td width=5%>0309</td>
    <td width=95%> [U] Integral type is not large enough to hold a pointer value.</td>
  </tr>
  <tr>
    <td width=5%>0327</td>
    <td width=95%> [I] Cast between a pointer to void and an floating type.</td>
  </tr>
  <tr>
    <td width=5%>0337</td>
    <td width=95%> [U] String literal has undefined value. This may be a result of using '#' on \\.</td>
  </tr>
  <tr>
    <td width=5%>0400</td>
    <td width=95%> [U] '%s' is modified more than once between sequence points - evaluation order unspecified.</td>
  </tr>
  <tr>
    <td width=5%>0401</td>
    <td width=95%> [U] '%s' may be modified more than once between sequence points - evaluation order unspecified.</td>
  </tr>
  <tr>
    <td width=5%>0402</td>
    <td width=95%> [U] '%s' is modified and accessed between sequence points - evaluation order unspecified.</td>
  </tr>
  <tr>
    <td width=5%>0403</td>
    <td width=95%> [U] '%s' may be modified and accessed between sequence points - evaluation order unspecified.</td>
  </tr>
  <tr>
    <td width=5%>0404</td>
    <td width=95%> More than one read access to volatile objects between sequence points.</td>
  </tr>
  <tr>
    <td width=5%>0405</td>
    <td width=95%> More than one modification of volatile objects between sequence points.</td>
  </tr>
  <tr>
    <td width=5%>0475</td>
    <td width=95%> [u] Operand of 'sizeof' is an expression designating a bit-field.</td>
  </tr>
  <tr>
    <td width=5%>0543</td>
    <td width=95%> [U] 'void' expressions have no value and may not be used in expressions.</td>
  </tr>
  <tr>
    <td width=5%>0544</td>
    <td width=95%> [U] The value of an incomplete 'union' may not be used.</td>
  </tr>
  <tr>
    <td width=5%>0545</td>
    <td width=95%> [U] The value of an incomplete 'struct' may not be used.</td>
  </tr>
  <tr>
    <td width=5%>0602</td>
    <td width=95%> [U] The identifier '%s' is reserved for use by the library.</td>
  </tr>
  <tr>
    <td width=5%>0603</td>
    <td width=95%> [U] The macro identifier '%s' is reserved.</td>
  </tr>
  <tr>
    <td width=5%>0623</td>
    <td width=95%> [U] '%s' has incomplete type and no linkage - this is undefined.</td>
  </tr>
  <tr>
    <td width=5%>0625</td>
    <td width=95%> [U] '%s' has been declared with both internal and external linkage - the behaviour is undefined.</td>
  </tr>
  <tr>
    <td width=5%>0626</td>
    <td width=95%> [U] '%s' has different type to previous declaration (which is no longer in scope).</td>
  </tr>
  <tr>
    <td width=5%>0630</td>
    <td width=95%> [U] More than one definition of '%s' (with external linkage).</td>
  </tr>
  <tr>
    <td width=5%>0632</td>
    <td width=95%> [U] Tentative definition of '%s' with internal linkage cannot have unknown size.</td>
  </tr>
  <tr>
    <td width=5%>0636</td>
    <td width=95%> [U] There are no named members in this 'struct' or 'union'.</td>
  </tr>
  <tr>
    <td width=5%>0654</td>
    <td width=95%> [U] Using 'const' or 'volatile' in a function return type is undefined.</td>
  </tr>
  <tr>
    <td width=5%>0658</td>
    <td width=95%> [U] Parameter cannot have 'void' type.</td>
  </tr>
  <tr>
    <td width=5%>0661</td>
    <td width=95%> [U] '%s()' may not have a storage class specifier of 'static' when declared at block scope.</td>
  </tr>
  <tr>
    <td width=5%>0667</td>
    <td width=95%> [U] '%s' is declared as a typedef and may not be redeclared as an object at an inner scope without an explicit type specifier.</td>
  </tr>
  <tr>
    <td width=5%>0668</td>
    <td width=95%> [U] '%s' is declared as a typedef and may not be redeclared as a member of a 'struct' or 'union' without an explicit type specifier.</td>
  </tr>
  <tr>
    <td width=5%>0672</td>
    <td width=95%> [U] The initializer for a 'struct', 'union' or array is not enclosed in braces.</td>
  </tr>
  <tr>
    <td width=5%>0676</td>
    <td width=95%> [u] Array element is of function type. Arrays cannot be constructed from function types.</td>
  </tr>
  <tr>
    <td width=5%>0678</td>
    <td width=95%> [u] Array element is array of unknown size. Arrays cannot be constructed from incomplete types.</td>
  </tr>
  <tr>
    <td width=5%>0680</td>
    <td width=95%> [u] Array element is 'void' or an incomplete 'struct' or 'union'. Arrays cannot be constructed from incomplete types.</td>
  </tr>
  <tr>
    <td width=5%>0706</td>
    <td width=95%> [U] Label '%s' is not unique within this function.</td>
  </tr>
  <tr>
    <td width=5%>0745</td>
    <td width=95%> [U] 'return;' found in '%s()', which has been defined with a non-'void' return type.</td>
  </tr>
  <tr>
    <td width=5%>0777</td>
    <td width=95%> [U] External identifier does not differ from other identifier(s) (e.g. '%s') within the specified number of significant characters.</td>
  </tr>
  <tr>
    <td width=5%>0779</td>
    <td width=95%> [U] Identifier does not differ from other identifier(s) (e.g. '%s') within the specified number of significant characters.</td>
  </tr>
  <tr>
    <td width=5%>0813</td>
    <td width=95%> [U] Using any of the characters ' " or /* in '#include <%s>' gives undefined behaviour.</td>
  </tr>
  <tr>
    <td width=5%>0814</td>
    <td width=95%> [U] Using the characters ' or /* in '#include "%s"' gives undefined behaviour.</td>
  </tr>
  <tr>
    <td width=5%>0836</td>
    <td width=95%> [U] Definition of macro named 'defined'.</td>
  </tr>
  <tr>
    <td width=5%>0837</td>
    <td width=95%> [U] Use of '#undef' to remove the operator 'defined'.</td>
  </tr>
  <tr>
    <td width=5%>0840</td>
    <td width=95%> [E] Extra tokens at end of #include directive.</td>
  </tr>
  <tr>
    <td width=5%>0848</td>
    <td width=95%> [U] Attempting to #undef '%s', which is a predefined macro name.</td>
  </tr>
  <tr>
    <td width=5%>0853</td>
    <td width=95%> [U] Macro arguments contain a sequence of tokens that has the form of a preprocessing directive.</td>
  </tr>
  <tr>
    <td width=5%>0854</td>
    <td width=95%> [U] Attempting to #define '%s', which is a predefined macro name.</td>
  </tr>
  <tr>
    <td width=5%>0864</td>
    <td width=95%> [U] '#line' directive specifies line number which is not in the range 1 to 32767.</td>
  </tr>
  <tr>
    <td width=5%>0865</td>
    <td width=95%> [U] '#line' directive is badly formed.</td>
  </tr>
  <tr>
    <td width=5%>0867</td>
    <td width=95%> [U] '#line' has not been followed by a line number.</td>
  </tr>
  <tr>
    <td width=5%>0872</td>
    <td width=95%> [U] Result of '##' operator is not a legal preprocessing token.</td>
  </tr>
  <tr>
    <td width=5%>0874</td>
    <td width=95%> [U] Character string literal and wide character string literal are adjacent.</td>
  </tr>
  <tr>
    <td width=5%>0885</td>
    <td width=95%> [U] The token 'defined' is generated in the expansion of this macro.</td>
  </tr>
  <tr>
    <td width=5%>0887</td>
    <td width=95%> [U] Use of 'defined' must match either 'defined(identifier)' or 'defined identifier'.</td>
  </tr>
  <tr>
    <td width=5%>0888</td>
    <td width=95%> [U] 'defined' requires an identifier as an argument.</td>
  </tr>
  <tr>
    <td width=5%>0914</td>
    <td width=95%> [U] Source file does not end with a newline character.</td>
  </tr>
  <tr>
    <td width=5%>0915</td>
    <td width=95%> [U] Source file ends with a backslash character followed by a newline.</td>
  </tr>
  <tr>
    <td width=5%>0942</td>
    <td width=95%> [U] A * can only be used to specify array size within function prototype scope.</td>
  </tr>
  <tr>
    <td width=5%>1331</td>
    <td width=95%> Type or number of arguments doesn't match previous use of the function.</td>
  </tr>
  <tr>
    <td width=5%>1332</td>
    <td width=95%> Type or number of arguments doesn't match prototype found later.</td>
  </tr>
  <tr>
    <td width=5%>1333</td>
    <td width=95%> Type or number of arguments doesn't match function definition found later.</td>
  </tr>
  <tr>
    <td width=5%>2800</td>
    <td width=95%> Constant: Overflow in signed arithmetic operation.</td>
  </tr>
  <tr>
    <td width=5%>2810</td>
    <td width=95%> Constant: Dereference of NULL pointer.</td>
  </tr>
  <tr>
    <td width=5%>2820</td>
    <td width=95%> Constant: Arithmetic operation on NULL pointer.</td>
  </tr>
  <tr>
    <td width=5%>2830</td>
    <td width=95%> Constant: Division by zero.</td>
  </tr>
  <tr>
    <td width=5%>2840</td>
    <td width=95%> Constant: Dereference of an invalid pointer value.</td>
  </tr>
  <tr>
    <td width=5%>3113</td>
    <td width=95%> [U] 'return' statement includes no expression but function '%s()' is implicitly of type 'int'.</td>
  </tr>
  <tr>
    <td width=5%>3114</td>
    <td width=95%> [U] Function '%s()' is implicitly of type 'int' but ends without returning a value.</td>
  </tr>
  <tr>
    <td width=5%>3239</td>
    <td width=95%> [U] inline function '%1s' has external linkage, but is not defined within this translation unit.</td>
  </tr>
  <tr>
    <td width=5%>3311</td>
    <td width=95%> [u] An earlier jump to this statement will bypass the initialization of local variables.</td>
  </tr>
  <tr>
    <td width=5%>3312</td>
    <td width=95%> [u] This goto statement will jump into a previous block and bypass the initialization of local variables.</td>
  </tr>
  <tr>
    <td width=5%>3319</td>
    <td width=95%> [U] Function called with number of arguments which differs from number of parameters in definition.</td>
  </tr>
  <tr>
    <td width=5%>3320</td>
    <td width=95%> Type of argument no. %s differs from its type in definition of function.</td>
  </tr>
  <tr>
    <td width=5%>3437</td>
    <td width=95%> [u] The assert macro has been suppressed to call a function of that name.</td>
  </tr>
  <tr>
    <td width=5%>3438</td>
    <td width=95%> [U] #undef'ing the assert macro to call a function of that name causes undefined behaviour.</td>
  </tr>
  <tr>
    <td width=5%>1509</td>
    <td width=95%> '%1s' has external linkage and has multiple definitions.</td>
  </tr>
  <tr>
    <td width=5%>1510</td>
    <td width=95%> '%1s' has external linkage and has incompatible declarations.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-10.1</td>
    <td width=2%>Required</td>
    <td width=50%>Operands shall not be of an inappropriate essential type.</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3101</td>
    <td width=95%> Unary '-' applied to an operand of type unsigned int or unsigned long gives an unsigned result.</td>
  </tr>
  <tr>
    <td width=5%>3102</td>
    <td width=95%> Unary '-' applied to an operand whose underlying type is unsigned.</td>
  </tr>
  <tr>
    <td width=5%>4500</td>
    <td width=95%> An expression of 'essentially Boolean' type (%1s) is being used as an array subscript.</td>
  </tr>
  <tr>
    <td width=5%>4501</td>
    <td width=95%> An expression of 'essentially Boolean' type (%1s) is being used as the %2s operand of this arithmetic operator (%3s).</td>
  </tr>
  <tr>
    <td width=5%>4502</td>
    <td width=95%> An expression of 'essentially Boolean' type (%1s) is being used as the %2s operand of this bitwise operator (%3s).</td>
  </tr>
  <tr>
    <td width=5%>4503</td>
    <td width=95%> An expression of 'essentially Boolean' type (%1s) is being used as the left-hand operand of this shift operator (%2s).</td>
  </tr>
  <tr>
    <td width=5%>4504</td>
    <td width=95%> An expression of 'essentially Boolean' type (%1s) is being used as the right-hand operand of this shift operator (%2s).</td>
  </tr>
  <tr>
    <td width=5%>4505</td>
    <td width=95%> An expression of 'essentially Boolean' type (%1s) is being used as the %2s operand of this relational operator (%3s).</td>
  </tr>
  <tr>
    <td width=5%>4507</td>
    <td width=95%> An expression of 'essentially Boolean' type (%1s) is being used as the operand of this increment/decrement operator (%2s).</td>
  </tr>
  <tr>
    <td width=5%>4510</td>
    <td width=95%> An expression of 'essentially character' type (%1s) is being used as an array subscript.</td>
  </tr>
  <tr>
    <td width=5%>4511</td>
    <td width=95%> An expression of 'essentially character' type (%1s) is being used as the %2s operand of this arithmetic operator (%3s).</td>
  </tr>
  <tr>
    <td width=5%>4512</td>
    <td width=95%> An expression of 'essentially character' type (%1s) is being used as the %2s operand of this bitwise operator (%3s).</td>
  </tr>
  <tr>
    <td width=5%>4513</td>
    <td width=95%> An expression of 'essentially character' type (%1s) is being used as the left-hand operand of this shift operator (%2s).</td>
  </tr>
  <tr>
    <td width=5%>4514</td>
    <td width=95%> An expression of 'essentially character' type (%1s) is being used as the right-hand operand of this shift operator (%2s).</td>
  </tr>
  <tr>
    <td width=5%>4518</td>
    <td width=95%> An expression of 'essentially character' type (%1s) is being used as the %2s operand of this logical operator (%3s).</td>
  </tr>
  <tr>
    <td width=5%>4519</td>
    <td width=95%> An expression of 'essentially character' type (%1s) is being used as the first operand of this conditional operator (%2s).</td>
  </tr>
  <tr>
    <td width=5%>4521</td>
    <td width=95%> An expression of 'essentially enum' type (%1s) is being used as the %2s operand of this arithmetic operator (%3s).</td>
  </tr>
  <tr>
    <td width=5%>4522</td>
    <td width=95%> An expression of 'essentially enum' type (%1s) is being used as the %2s operand of this bitwise operator (%3s).</td>
  </tr>
  <tr>
    <td width=5%>4523</td>
    <td width=95%> An expression of 'essentially enum' type (%1s) is being used as the left-hand operand of this shift operator (%2s).</td>
  </tr>
  <tr>
    <td width=5%>4524</td>
    <td width=95%> An expression of 'essentially enum' type (%1s) is being used as the right-hand operand of this shift operator (%2s).</td>
  </tr>
  <tr>
    <td width=5%>4527</td>
    <td width=95%> An expression of 'essentially enum' type is being used as the operand of this increment/decrement operator.</td>
  </tr>
  <tr>
    <td width=5%>4528</td>
    <td width=95%> An expression of 'essentially enum' type (%1s) is being used as the %2s operand of this logical operator (%3s).</td>
  </tr>
  <tr>
    <td width=5%>4529</td>
    <td width=95%> An expression of 'essentially enum' type (%1s) is being used as the first operand of this conditional operator (%2s).</td>
  </tr>
  <tr>
    <td width=5%>4532</td>
    <td width=95%> An expression of 'essentially signed' type (%1s) is being used as the %2s operand of this bitwise operator (%3s).</td>
  </tr>
  <tr>
    <td width=5%>4533</td>
    <td width=95%> An expression of 'essentially signed' type (%1s) is being used as the left-hand operand of this shift operator (%2s).</td>
  </tr>
  <tr>
    <td width=5%>4534</td>
    <td width=95%> An expression of 'essentially signed' type (%1s) is being used as the right-hand operand of this shift operator (%2s).</td>
  </tr>
  <tr>
    <td width=5%>4538</td>
    <td width=95%> An expression of 'essentially signed' type (%1s) is being used as the %2s operand of this logical operator (%3s).</td>
  </tr>
  <tr>
    <td width=5%>4539</td>
    <td width=95%> An expression of 'essentially signed' type (%1s) is being used as the first operand of this conditional operator (%2s).</td>
  </tr>
  <tr>
    <td width=5%>4542</td>
    <td width=95%> A non-negative constant expression of 'essentially signed' type (%1s) is being used as the %2s operand of this bitwise operator (%3s).</td>
  </tr>
  <tr>
    <td width=5%>4543</td>
    <td width=95%> A non-negative constant expression of 'essentially signed' type (%1s) is being used as the left-hand operand of this shift operator (%2s).</td>
  </tr>
  <tr>
    <td width=5%>4548</td>
    <td width=95%> A non-negative constant expression of 'essentially signed' type (%1s) is being used as the %2s operand of this logical operator (%3s).</td>
  </tr>
  <tr>
    <td width=5%>4549</td>
    <td width=95%> A non-negative constant expression of 'essentially signed' type (%1s) is being used as the first operand of this conditional operator (%2s).</td>
  </tr>
  <tr>
    <td width=5%>4558</td>
    <td width=95%> An expression of 'essentially unsigned' type (%1s) is being used as the %2s operand of this logical operator (%3s).</td>
  </tr>
  <tr>
    <td width=5%>4559</td>
    <td width=95%> An expression of 'essentially unsigned' type (%1s) is being used as the first operand of this conditional operator (%2s).</td>
  </tr>
  <tr>
    <td width=5%>4568</td>
    <td width=95%> An expression of 'essentially floating' type (%1s) is being used as the %2s operand of this logical operator (%3s).</td>
  </tr>
  <tr>
    <td width=5%>4569</td>
    <td width=95%> An expression of 'essentially floating' type (%1s) is being used as the first operand of this conditional operator (%2s).</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-10.2</td>
    <td width=2%>Required</td>
    <td width=50%>Expressions of essentially character type shall not be used inappropriately in addition and subtraction operations</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>1810</td>
    <td width=95%> An operand of 'essentially character' type is being added to another operand of 'essentially character' type.</td>
  </tr>
  <tr>
    <td width=5%>1811</td>
    <td width=95%> An operand of 'essentially character' type is being subtracted from an operand of 'essentially signed' type.</td>
  </tr>
  <tr>
    <td width=5%>1812</td>
    <td width=95%> An operand of 'essentially character' type is being subtracted from an operand of 'essentially unsigned' type.</td>
  </tr>
  <tr>
    <td width=5%>1813</td>
    <td width=95%> An operand of 'essentially character' type is being balanced with an operand of 'essentially floating' type in this arithmetic operation.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-10.3</td>
    <td width=2%>Required</td>
    <td width=50%>The value of an expression shall not be assigned to an object with a narrower essential type or of a different essential type category.</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0570</td>
    <td width=95%> This switch case label of 'essential type' '%1s', is not consistent with a controlling expression of essential type '%2s'.</td>
  </tr>
  <tr>
    <td width=5%>0572</td>
    <td width=95%> This switch case label of 'essential type' '%1s' is not consistent with a controlling expression which has an essential type of lower rank (%2s).</td>
  </tr>
  <tr>
    <td width=5%>1257</td>
    <td width=95%> An integer constant suffixed with L or LL is being converted to a type of lower rank on assignment.</td>
  </tr>
  <tr>
    <td width=5%>1264</td>
    <td width=95%> A suffixed floating constant is being converted to a different floating type on assignment.</td>
  </tr>
  <tr>
    <td width=5%>1265</td>
    <td width=95%> An unsuffixed floating constant is being converted to a different floating type on assignment.</td>
  </tr>
  <tr>
    <td width=5%>1266</td>
    <td width=95%> A floating constant is being converted to integral type on assignment.</td>
  </tr>
  <tr>
    <td width=5%>1291</td>
    <td width=95%> An integer constant of 'essentially unsigned' type is being converted to signed type on assignment.</td>
  </tr>
  <tr>
    <td width=5%>1292</td>
    <td width=95%> An integer constant of 'essentially signed' type is being converted to type char on assignment.</td>
  </tr>
  <tr>
    <td width=5%>1293</td>
    <td width=95%> An integer constant of 'essentially unsigned' type is being converted to type char on assignment.</td>
  </tr>
  <tr>
    <td width=5%>1294</td>
    <td width=95%> An integer constant of 'essentially signed' type is being converted to type _Bool on assignment.</td>
  </tr>
  <tr>
    <td width=5%>1295</td>
    <td width=95%> An integer constant of 'essentially unsigned' type is being converted to type _Bool on assignment.</td>
  </tr>
  <tr>
    <td width=5%>1296</td>
    <td width=95%> An integer constant of 'essentially signed' type is being converted to enum type on assignment.</td>
  </tr>
  <tr>
    <td width=5%>1297</td>
    <td width=95%> An integer constant of 'essentially unsigned' type is being converted to enum type on assignment.</td>
  </tr>
  <tr>
    <td width=5%>1298</td>
    <td width=95%> An integer constant of 'essentially signed' type is being converted to floating type on assignment.</td>
  </tr>
  <tr>
    <td width=5%>1299</td>
    <td width=95%> An integer constant of 'essentially unsigned' type is being converted to floating type on assignment.</td>
  </tr>
  <tr>
    <td width=5%>2850</td>
    <td width=95%> Constant: Implicit conversion to a signed integer type of insufficient size.</td>
  </tr>
  <tr>
    <td width=5%>2890</td>
    <td width=95%> Constant: Negative value implicitly converted to an unsigned type.</td>
  </tr>
  <tr>
    <td width=5%>2900</td>
    <td width=95%> Constant: Positive integer value truncated by implicit conversion to a smaller unsigned type.</td>
  </tr>
  <tr>
    <td width=5%>4401</td>
    <td width=95%> An expression of 'essentially Boolean' type (%1s) is being converted to character type, '%2s' on assignment.</td>
  </tr>
  <tr>
    <td width=5%>4402</td>
    <td width=95%> An expression of 'essentially Boolean' type (%1s) is being converted to enum type, '%2s' on assignment.</td>
  </tr>
  <tr>
    <td width=5%>4403</td>
    <td width=95%> An expression of 'essentially Boolean' type (%1s) is being converted to signed type, '%2s' on assignment.</td>
  </tr>
  <tr>
    <td width=5%>4404</td>
    <td width=95%> An expression of 'essentially Boolean' type (%1s) is being converted to unsigned type, '%2s' on assignment.</td>
  </tr>
  <tr>
    <td width=5%>4405</td>
    <td width=95%> An expression of 'essentially Boolean' type (%1s) is being converted to floating type, '%2s' on assignment.</td>
  </tr>
  <tr>
    <td width=5%>4410</td>
    <td width=95%> An expression of 'essentially character' type (%1s) is being converted to Boolean type, '%2s' on assignment.</td>
  </tr>
  <tr>
    <td width=5%>4412</td>
    <td width=95%> An expression of 'essentially character' type (%1s) is being converted to enum type, '%2s' on assignment.</td>
  </tr>
  <tr>
    <td width=5%>4413</td>
    <td width=95%> An expression of 'essentially character' type (%1s) is being converted to signed type, '%2s' on assignment.</td>
  </tr>
  <tr>
    <td width=5%>4414</td>
    <td width=95%> An expression of 'essentially character' type (%1s) is being converted to unsigned type, '%2s' on assignment.</td>
  </tr>
  <tr>
    <td width=5%>4415</td>
    <td width=95%> An expression of 'essentially character' type (%1s) is being converted to floating type, '%2s' on assignment.</td>
  </tr>
  <tr>
    <td width=5%>4420</td>
    <td width=95%> An expression of 'essentially enum' type (%1s) is being converted to Boolean type, '%2s' on assignment.</td>
  </tr>
  <tr>
    <td width=5%>4421</td>
    <td width=95%> An expression of 'essentially enum' type (%1s) is being converted to character type, '%2s' on assignment.</td>
  </tr>
  <tr>
    <td width=5%>4422</td>
    <td width=95%> An expression of 'essentially enum' type (%1s) is being converted to a different enum type, '%2s' on assignment.</td>
  </tr>
  <tr>
    <td width=5%>4423</td>
    <td width=95%> An expression of 'essentially enum' type (%1s) is being converted to signed type, '%2s' on assignment.</td>
  </tr>
  <tr>
    <td width=5%>4424</td>
    <td width=95%> An expression of 'essentially enum' type (%1s) is being converted to unsigned type, '%2s' on assignment.</td>
  </tr>
  <tr>
    <td width=5%>4425</td>
    <td width=95%> An expression of 'essentially enum' type (%1s) is being converted to floating type, '%2s' on assignment.</td>
  </tr>
  <tr>
    <td width=5%>4430</td>
    <td width=95%> An expression of 'essentially signed' type (%1s) is being converted to Boolean type, '%2s' on assignment.</td>
  </tr>
  <tr>
    <td width=5%>4431</td>
    <td width=95%> An expression of 'essentially signed' type (%1s) is being converted to character type, '%2s' on assignment.</td>
  </tr>
  <tr>
    <td width=5%>4432</td>
    <td width=95%> An expression of 'essentially signed' type (%1s) is being converted to enum type, '%2s' on assignment.</td>
  </tr>
  <tr>
    <td width=5%>4434</td>
    <td width=95%> A non-constant expression of 'essentially signed' type (%1s) is being converted to unsigned type, '%2s' on assignment.</td>
  </tr>
  <tr>
    <td width=5%>4435</td>
    <td width=95%> A non-constant expression of 'essentially signed' type (%1s) is being converted to floating type, '%2s' on assignment.</td>
  </tr>
  <tr>
    <td width=5%>4437</td>
    <td width=95%> A constant expression of 'essentially signed' type (%1s) is being converted to floating type, '%2s' on assignment.</td>
  </tr>
  <tr>
    <td width=5%>4440</td>
    <td width=95%> An expression of 'essentially unsigned' type (%1s) is being converted to Boolean type, '%2s' on assignment.</td>
  </tr>
  <tr>
    <td width=5%>4441</td>
    <td width=95%> An expression of 'essentially unsigned' type (%1s) is being converted to character type, '%2s' on assignment.</td>
  </tr>
  <tr>
    <td width=5%>4442</td>
    <td width=95%> An expression of 'essentially unsigned' type (%1s) is being converted to enum type, '%2s' on assignment.</td>
  </tr>
  <tr>
    <td width=5%>4443</td>
    <td width=95%> A non-constant expression of 'essentially unsigned' type (%1s) is being converted to a wider signed type, '%2s' on assignment.</td>
  </tr>
  <tr>
    <td width=5%>4445</td>
    <td width=95%> An expression of 'essentially unsigned' type (%1s) is being converted to floating type, '%2s' on assignment.</td>
  </tr>
  <tr>
    <td width=5%>4446</td>
    <td width=95%> A non-constant expression of 'essentially unsigned' type (%1s) is being converted to signed type, '%2s' on assignment.</td>
  </tr>
  <tr>
    <td width=5%>4447</td>
    <td width=95%> A constant expression of 'essentially unsigned' type (%1s) is being converted to signed type, '%2s' on assignment.</td>
  </tr>
  <tr>
    <td width=5%>4450</td>
    <td width=95%> An expression of 'essentially floating' type (%1s) is being converted to Boolean type, '%2s' on assignment.</td>
  </tr>
  <tr>
    <td width=5%>4451</td>
    <td width=95%> An expression of 'essentially floating' type (%1s) is being converted to character type, '%2s' on assignment.</td>
  </tr>
  <tr>
    <td width=5%>4452</td>
    <td width=95%> An expression of 'essentially floating' type (%1s) is being converted to enum type, '%2s' on assignment.</td>
  </tr>
  <tr>
    <td width=5%>4453</td>
    <td width=95%> An expression of 'essentially floating' type (%1s) is being converted to signed type, '%2s' on assignment.</td>
  </tr>
  <tr>
    <td width=5%>4454</td>
    <td width=95%> An expression of 'essentially floating' type (%1s) is being converted to unsigned type, '%2s' on assignment.</td>
  </tr>
  <tr>
    <td width=5%>4460</td>
    <td width=95%> A non-constant expression of 'essentially signed' type (%1s) is being converted to narrower signed type, '%2s' on assignment.</td>
  </tr>
  <tr>
    <td width=5%>4461</td>
    <td width=95%> A non-constant expression of 'essentially unsigned' type (%1s) is being converted to narrower unsigned type, '%2s' on assignment.</td>
  </tr>
  <tr>
    <td width=5%>4462</td>
    <td width=95%> A non-constant expression of 'essentially floating' type (%1s) is being converted to narrower floating type, '%2s' on assignment.</td>
  </tr>
  <tr>
    <td width=5%>4463</td>
    <td width=95%> A constant expression of 'essentially signed' type (%1s) is being converted to narrower signed type, '%2s' on assignment.</td>
  </tr>
  <tr>
    <td width=5%>4464</td>
    <td width=95%> A constant expression of 'essentially unsigned' type (%1s) is being converted to narrower unsigned type, '%2s' on assignment.</td>
  </tr>
  <tr>
    <td width=5%>4465</td>
    <td width=95%> A constant expression of 'essentially floating' type (%1s) is being converted to narrower floating type, '%2s' on assignment.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-10.4</td>
    <td width=2%>Required</td>
    <td width=50%>Both operands of an operator in which the usual arithmetic conversions are performed shall have the same essential type category</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>1800</td>
    <td width=95%> The %1s operand (essential type: '%2s') will be implicitly converted to a floating type, '%3s', in this arithmetic operation.</td>
  </tr>
  <tr>
    <td width=5%>1802</td>
    <td width=95%> The %1s operand (essential type: '%2s') will be implicitly converted to a floating type, '%3s', in this relational operation.</td>
  </tr>
  <tr>
    <td width=5%>1803</td>
    <td width=95%> The %1s operand (essential type: '%2s') will be implicitly converted to a floating type, '%3s', in this equality operation.</td>
  </tr>
  <tr>
    <td width=5%>1804</td>
    <td width=95%> The %1s operand (essential type: '%2s') will be implicitly converted to a floating type, '%3s', in this conditional operation.</td>
  </tr>
  <tr>
    <td width=5%>1820</td>
    <td width=95%> The %1s operand is non-constant and 'essentially signed' (%2s) but will be implicitly converted to an unsigned type (%3s) in this arithmetic operation.</td>
  </tr>
  <tr>
    <td width=5%>1821</td>
    <td width=95%> The %1s operand is non-constant and 'essentially signed' (%2s) but will be implicitly converted to an unsigned type (%3s) in this bitwise operation.</td>
  </tr>
  <tr>
    <td width=5%>1822</td>
    <td width=95%> The %1s operand is non-constant and 'essentially signed' (%2s) but will be implicitly converted to an unsigned type (%3s) in this relational operation.</td>
  </tr>
  <tr>
    <td width=5%>1823</td>
    <td width=95%> The %1s operand is non-constant and 'essentially signed' (%2s) but will be implicitly converted to an unsigned type (%3s) in this equality operation.</td>
  </tr>
  <tr>
    <td width=5%>1824</td>
    <td width=95%> The %1s operand is non-constant and 'essentially signed' (%2s) but will be implicitly converted to an unsigned type (%3s) in this conditional operation.</td>
  </tr>
  <tr>
    <td width=5%>1830</td>
    <td width=95%> The %1s operand is constant, 'essentially signed' (%2s) and negative but will be implicitly converted to an unsigned type (%3s) in this arithmetic operation.</td>
  </tr>
  <tr>
    <td width=5%>1831</td>
    <td width=95%> The %1s operand is constant, 'essentially signed' (%2s) and negative but will be implicitly converted to an unsigned type (%3s) in this bitwise operation.</td>
  </tr>
  <tr>
    <td width=5%>1832</td>
    <td width=95%> The %1s operand is constant, 'essentially signed' (%2s) and negative but will be implicitly converted to an unsigned type (%3s) in this relational operation.</td>
  </tr>
  <tr>
    <td width=5%>1833</td>
    <td width=95%> The %1s operand is constant, 'essentially signed' (%2s) and negative but will be implicitly converted to an unsigned type (%3s) in this equality operation.</td>
  </tr>
  <tr>
    <td width=5%>1834</td>
    <td width=95%> The %1s operand is constant, 'essentially signed' (%2s) and negative but will be implicitly converted to an unsigned type (%3s) in this conditional operation.</td>
  </tr>
  <tr>
    <td width=5%>1840</td>
    <td width=95%> The %1s operand is constant, 'essentially signed' (%2s) and non-negative but will be implicitly converted to an unsigned type (%3s) in this arithmetic operation.</td>
  </tr>
  <tr>
    <td width=5%>1841</td>
    <td width=95%> The %1s operand is constant, 'essentially signed' (%2s) and non-negative but will be implicitly converted to an unsigned type (%3s) in this bitwise operation.</td>
  </tr>
  <tr>
    <td width=5%>1842</td>
    <td width=95%> The %1s operand is constant, 'essentially signed' (%2s) and non-negative but will be implicitly converted to an unsigned type (%3s) in this relational operation.</td>
  </tr>
  <tr>
    <td width=5%>1843</td>
    <td width=95%> The %1s operand is constant, 'essentially signed' (%2s) and non-negative but will be implicitly converted to an unsigned type (%3s) in this equality operation.</td>
  </tr>
  <tr>
    <td width=5%>1844</td>
    <td width=95%> The %1s operand is constant, 'essentially signed' (%2s) and non-negative but will be implicitly converted to an unsigned type (%3s) in this conditional operation.</td>
  </tr>
  <tr>
    <td width=5%>1850</td>
    <td width=95%> The %1s operand is 'essentially unsigned' (%2s) but will be implicitly converted to a signed type (%3s) in this arithmetic operation.</td>
  </tr>
  <tr>
    <td width=5%>1851</td>
    <td width=95%> The %1s operand is 'essentially unsigned' (%2s) but will be implicitly converted to a signed type (%3s) in this bitwise operation.</td>
  </tr>
  <tr>
    <td width=5%>1852</td>
    <td width=95%> The %1s operand is 'essentially unsigned' (%2s) but will be implicitly converted to a signed type (%3s) in this relational operation.</td>
  </tr>
  <tr>
    <td width=5%>1853</td>
    <td width=95%> The %1s operand is 'essentially unsigned' (%2s) but will be implicitly converted to a signed type (%3s) in this equality operation.</td>
  </tr>
  <tr>
    <td width=5%>1854</td>
    <td width=95%> The %1s operand is 'essentially unsigned' (%2s) but will be implicitly converted to a signed type (%3s) in this conditional operation.</td>
  </tr>
  <tr>
    <td width=5%>1860</td>
    <td width=95%> The operands of this arithmetic operator are of different 'essential signedness' but will generate a result of type 'signed int'.</td>
  </tr>
  <tr>
    <td width=5%>1861</td>
    <td width=95%> The operands of this bitwise operator are of different 'essential signedness' but will generate a result of type 'signed int'.</td>
  </tr>
  <tr>
    <td width=5%>1862</td>
    <td width=95%> The operands of this relational operator are of different 'essential signedness' but will both be promoted to 'signed int' for comparison.</td>
  </tr>
  <tr>
    <td width=5%>1863</td>
    <td width=95%> The operands of this equality operator are of different 'essential signedness' but will both be promoted to 'signed int' for comparison.</td>
  </tr>
  <tr>
    <td width=5%>1864</td>
    <td width=95%> The 2nd and 3rd operands of this conditional operator are of different 'essential signedness'. The result will be in the promoted type 'signed int'.</td>
  </tr>
  <tr>
    <td width=5%>1880</td>
    <td width=95%> The operands of this relational operator are expressions of different 'essential type' categories (%1s and %2s).</td>
  </tr>
  <tr>
    <td width=5%>1881</td>
    <td width=95%> The operands of this equality operator are expressions of different 'essential type' categories (%1s and %2s).</td>
  </tr>
  <tr>
    <td width=5%>1882</td>
    <td width=95%> The 2nd and 3rd operands of this conditional operator are expressions of different 'essential type' categories (%1s and %2s).</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-10.5</td>
    <td width=2%>Advisory</td>
    <td width=50%>The value of an expression should not be cast to an inappropriate essential type</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>4301</td>
    <td width=95%> An expression of 'essentially Boolean' type (%1s) is being cast to character type '%2s'.</td>
  </tr>
  <tr>
    <td width=5%>4302</td>
    <td width=95%> An expression of 'essentially Boolean' type (%1s) is being cast to enum type '%2s'.</td>
  </tr>
  <tr>
    <td width=5%>4303</td>
    <td width=95%> An expression of 'essentially Boolean' type (%1s) is being cast to signed type '%2s'.</td>
  </tr>
  <tr>
    <td width=5%>4304</td>
    <td width=95%> An expression of 'essentially Boolean' type (%1s) is being cast to unsigned type '%2s'.</td>
  </tr>
  <tr>
    <td width=5%>4305</td>
    <td width=95%> An expression of 'essentially Boolean' type (%1s) is being cast to floating type '%2s'.</td>
  </tr>
  <tr>
    <td width=5%>4310</td>
    <td width=95%> An expression of 'essentially character' type (%1s) is being cast to Boolean type, '%2s'.</td>
  </tr>
  <tr>
    <td width=5%>4312</td>
    <td width=95%> An expression of 'essentially character' type (%1s) is being cast to enum type, '%2s'.</td>
  </tr>
  <tr>
    <td width=5%>4315</td>
    <td width=95%> An expression of 'essentially character' type (%1s) is being cast to floating type, '%2s'.</td>
  </tr>
  <tr>
    <td width=5%>4320</td>
    <td width=95%> An expression of 'essentially enum' type (%1s) is being cast to Boolean type, '%2s'.</td>
  </tr>
  <tr>
    <td width=5%>4322</td>
    <td width=95%> An expression of 'essentially enum' type (%1s) is being cast to a different enum type, '%2s'.</td>
  </tr>
  <tr>
    <td width=5%>4330</td>
    <td width=95%> An expression of 'essentially signed' type (%1s) is being cast to Boolean type '%2s'.</td>
  </tr>
  <tr>
    <td width=5%>4332</td>
    <td width=95%> An expression of 'essentially signed' type (%1s) is being cast to enum type, '%2s'.</td>
  </tr>
  <tr>
    <td width=5%>4340</td>
    <td width=95%> An expression of 'essentially unsigned' type (%1s) is being cast to Boolean type '%2s'.</td>
  </tr>
  <tr>
    <td width=5%>4342</td>
    <td width=95%> An expression of 'essentially unsigned' type (%1s) is being cast to enum type '%2s'.</td>
  </tr>
  <tr>
    <td width=5%>4350</td>
    <td width=95%> An expression of 'essentially floating' type (%1s) is being cast to Boolean type '%2s'.</td>
  </tr>
  <tr>
    <td width=5%>4351</td>
    <td width=95%> An expression of 'essentially floating' type (%1s) is being cast to character type '%2s'.</td>
  </tr>
  <tr>
    <td width=5%>4352</td>
    <td width=95%> An expression of 'essentially floating' type (%1s) is being cast to enum type, '%2s'.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-10.6</td>
    <td width=2%>Required</td>
    <td width=50%>The value of a composite expression shall not be assigned to an object with wider essential type</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>4490</td>
    <td width=95%> A composite expression of 'essentially signed' type (%1s) is being converted to wider signed type, '%2s' on assignment.</td>
  </tr>
  <tr>
    <td width=5%>4491</td>
    <td width=95%> A composite expression of 'essentially unsigned' type (%1s) is being converted to wider unsigned type, '%2s' on assignment.</td>
  </tr>
  <tr>
    <td width=5%>4492</td>
    <td width=95%> A composite expression of 'essentially floating' type (%1s) is being converted to wider floating type, '%2s' on assignment.</td>
  </tr>
  <tr>
    <td width=5%>4499</td>
    <td width=95%> An expression which is the result of a ~ or << operation has been converted to a wider essential type on assignment.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-10.7</td>
    <td width=2%>Required</td>
    <td width=50%>If a composite expression is used as one operand of an operator in which the usual arithmetic conversions are performed then the other operand shall not have wider essential type</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>1890</td>
    <td width=95%> A composite expression of 'essentially signed' type (%1s) is being implicitly converted to a wider signed type, '%2s'.</td>
  </tr>
  <tr>
    <td width=5%>1891</td>
    <td width=95%> A composite expression of 'essentially unsigned' type (%1s) is being implicitly converted to a wider unsigned type, '%2s'.</td>
  </tr>
  <tr>
    <td width=5%>1892</td>
    <td width=95%> A composite expression of 'essentially floating' type (%1s) is being implicitly converted to a wider floating type, '%2s'.</td>
  </tr>
  <tr>
    <td width=5%>1893</td>
    <td width=95%> The 2nd and 3rd operands of this conditional operator are both 'essentially signed' ('%1s' and '%2s') but one is a composite expression of a narrower type than the other.</td>
  </tr>
  <tr>
    <td width=5%>1894</td>
    <td width=95%> The 2nd and 3rd operands of this conditional operator are both 'essentially unsigned' ('%1s' and '%2s') but one is a composite expression of a narrower type than the other.</td>
  </tr>
  <tr>
    <td width=5%>1895</td>
    <td width=95%> The 2nd and 3rd operands of this conditional operator are both 'essentially floating' ('%1s' and '%2s') but one is a composite expression of a narrower type than the other.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-10.8</td>
    <td width=2%>Required</td>
    <td width=50%>The value of a composite expression shall not be cast to a different essential type category or a wider essential type</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>4389</td>
    <td width=95%> A composite expression of 'essentially char' type (%1s) is being cast to a different type category, '%2s'.</td>
  </tr>
  <tr>
    <td width=5%>4390</td>
    <td width=95%> A composite expression of 'essentially signed' type (%1s) is being cast to a wider signed type, '%2s'.</td>
  </tr>
  <tr>
    <td width=5%>4391</td>
    <td width=95%> A composite expression of 'essentially unsigned' type (%1s) is being cast to a wider unsigned type, '%2s'.</td>
  </tr>
  <tr>
    <td width=5%>4392</td>
    <td width=95%> A composite expression of 'essentially floating' type (%1s) is being cast to a wider floating type, '%2s'.</td>
  </tr>
  <tr>
    <td width=5%>4393</td>
    <td width=95%> A composite expression of 'essentially signed' type (%1s) is being cast to a different type category, '%2s'.</td>
  </tr>
  <tr>
    <td width=5%>4394</td>
    <td width=95%> A composite expression of 'essentially unsigned' type (%1s) is being cast to a different type category, '%2s'.</td>
  </tr>
  <tr>
    <td width=5%>4395</td>
    <td width=95%> A composite expression of 'essentially floating' type (%1s) is being cast to a different type category, '%2s'.</td>
  </tr>
  <tr>
    <td width=5%>4398</td>
    <td width=95%> An expression which is the result of a ~ or << operation has been cast to a different essential type category.</td>
  </tr>
  <tr>
    <td width=5%>4399</td>
    <td width=95%> An expression which is the result of a ~ or << operation has been cast to a wider type.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-11.1</td>
    <td width=2%>Required</td>
    <td width=50%>Conversions shall not be performed between a pointer to a function and any other type</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0302</td>
    <td width=95%> [u] Cast between a pointer to function and a floating type.</td>
  </tr>
  <tr>
    <td width=5%>0305</td>
    <td width=95%> [I] Cast between a pointer to function and an integral type.</td>
  </tr>
  <tr>
    <td width=5%>0307</td>
    <td width=95%> [u] Cast between a pointer to object and a pointer to function.</td>
  </tr>
  <tr>
    <td width=5%>0313</td>
    <td width=95%> Casting to different function pointer type.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-11.2</td>
    <td width=2%>Required</td>
    <td width=50%>Conversions shall not be performed between a pointer to an incomplete type and any other type</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0308</td>
    <td width=95%> Non-portable cast involving pointer to an incomplete type.</td>
  </tr>
  <tr>
    <td width=5%>0323</td>
    <td width=95%> [u] Cast between a pointer to incomplete type and a floating type.</td>
  </tr>
  <tr>
    <td width=5%>0324</td>
    <td width=95%> [u] Cast between a pointer to incomplete type and an integral type.</td>
  </tr>
  <tr>
    <td width=5%>0325</td>
    <td width=95%> [u] Cast between a pointer to incomplete type and a pointer to function.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-11.3</td>
    <td width=2%>Required</td>
    <td width=50%>A cast shall not be performed between a pointer to object type and a pointer to a different object type</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0310</td>
    <td width=95%> Casting to different object pointer type.</td>
  </tr>
  <tr>
    <td width=5%>3305</td>
    <td width=95%> Pointer cast to stricter alignment.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-11.4</td>
    <td width=2%>Advisory</td>
    <td width=50%>A conversion should not be performed between a pointer to object and an integer type</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0303</td>
    <td width=95%> [I] Cast between a pointer to volatile object and an integral type.</td>
  </tr>
  <tr>
    <td width=5%>0306</td>
    <td width=95%> [I] Cast between a pointer to object and an integral type.</td>
  </tr>
  <tr>
    <td width=5%>0360</td>
    <td width=95%> An expression of pointer type is being converted to type _Bool on assignment.</td>
  </tr>
  <tr>
    <td width=5%>0361</td>
    <td width=95%> An expression of pointer type is being cast to type _Bool.</td>
  </tr>
  <tr>
    <td width=5%>0362</td>
    <td width=95%> An expression of essentially Boolean type is being cast to a pointer.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-11.5</td>
    <td width=2%>Advisory</td>
    <td width=50%>A conversion should not be performed from pointer to void into pointer to object</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0316</td>
    <td width=95%> [I] Cast from a pointer to void to a pointer to object type.</td>
  </tr>
  <tr>
    <td width=5%>0317</td>
    <td width=95%> [I] Implicit conversion from a pointer to void to a pointer to object type.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-11.6</td>
    <td width=2%>Required</td>
    <td width=50%>A cast shall not be performed between pointer to void and an arithmetic type</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0326</td>
    <td width=95%> [I] Cast between a pointer to void and an integral type.</td>
  </tr>
  <tr>
    <td width=5%>0327</td>
    <td width=95%> [I] Cast between a pointer to void and an floating type.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-11.7</td>
    <td width=2%>Required</td>
    <td width=50%>A cast shall not be performed between pointer to object and a non-integer arithmetic type</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0301</td>
    <td width=95%> [u] Cast between a pointer to object and a floating type.</td>
  </tr>
  <tr>
    <td width=5%>0328</td>
    <td width=95%> [u] Cast between a pointer to object and an essential type other than signed/unsigned.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-11.8</td>
    <td width=2%>Required</td>
    <td width=50%>A cast shall not remove any const or volatile qualification from the type pointed to by a pointer</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0311</td>
    <td width=95%> Dangerous pointer cast results in loss of const qualification.</td>
  </tr>
  <tr>
    <td width=5%>0312</td>
    <td width=95%> Dangerous pointer cast results in loss of volatile qualification.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-11.9</td>
    <td width=2%>Required</td>
    <td width=50%>The macro NULL shall be the only permitted form of integer null pointer constant</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3003</td>
    <td width=95%> This character constant is being interpreted as a NULL pointer constant.</td>
  </tr>
  <tr>
    <td width=5%>3004</td>
    <td width=95%> This integral constant expression is being interpreted as a NULL pointer constant.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-12.1</td>
    <td width=2%>Advisory</td>
    <td width=50%>The precedence of operators within expressions should be made explicit</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3389</td>
    <td width=95%> Extra parentheses recommended to clarify the ordering of a % operator and another arithmetic operator (* / % + -).</td>
  </tr>
  <tr>
    <td width=5%>3391</td>
    <td width=95%> Extra parentheses recommended. A conditional operation is the operand of another conditional operator.</td>
  </tr>
  <tr>
    <td width=5%>3392</td>
    <td width=95%> Extra parentheses recommended. A shift, relational or equality operation is the operand of a second identical operator.</td>
  </tr>
  <tr>
    <td width=5%>3394</td>
    <td width=95%> Extra parentheses recommended. A shift, relational or equality operation is the operand of a different operator with the same precedence.</td>
  </tr>
  <tr>
    <td width=5%>3395</td>
    <td width=95%> Extra parentheses recommended. A * or / operation is the operand of a + or - operator.</td>
  </tr>
  <tr>
    <td width=5%>3396</td>
    <td width=95%> Extra parentheses recommended. A binary operation is the operand of a conditional operator.</td>
  </tr>
  <tr>
    <td width=5%>3397</td>
    <td width=95%> Extra parentheses recommended. A binary operation is the operand of a binary operator with different precedence.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-12.2</td>
    <td width=2%>Required</td>
    <td width=50%>The right hand operand of a shift operator shall lie in the range zero to one less than the width in bits of the essential type of the left hand operand</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0499</td>
    <td width=95%> Right operand of shift operator is greater than or equal to the width of the essential type of the left operand.</td>
  </tr>
  <tr>
    <td width=5%>2790</td>
    <td width=95%> Constant: Right hand operand of shift operator is negative or too large.</td>
  </tr>
  <tr>
    <td width=5%>2791</td>
    <td width=95%> Definite: Right hand operand of shift operator is negative or too large.</td>
  </tr>
  <tr>
    <td width=5%>2792</td>
    <td width=95%> Apparent: Right hand operand of shift operator is negative or too large.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-12.3</td>
    <td width=2%>Advisory</td>
    <td width=50%>The comma operator should not be used</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3417</td>
    <td width=95%> The comma operator has been used outside a 'for' statement.</td>
  </tr>
  <tr>
    <td width=5%>3418</td>
    <td width=95%> The comma operator has been used in a 'for' statement.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-12.4</td>
    <td width=2%>Advisory</td>
    <td width=50%>Evaluation of constant expressions should not lead to unsigned integer wrap-around</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>2910</td>
    <td width=95%> Constant: Wraparound in unsigned arithmetic operation.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-12.5</td>
    <td width=2%>Mandatory</td>
    <td width=50%>The sizeof operator shall not have an operand which is a function parameter declared as 'array of type'</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>1321</td>
    <td width=95%> Operand of sizeof is a function parameter of array type.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-13.1</td>
    <td width=2%>Required</td>
    <td width=50%>Initializer lists shall not contain persistent side-effects</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3421</td>
    <td width=95%> Expression with possible side effects is used in an initializer list.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-13.2</td>
    <td width=2%>Required</td>
    <td width=50%>The value of an expression and its persistent side-effects shall be the same under all permitted evaluation orders</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0400</td>
    <td width=95%> [U] '%s' is modified more than once between sequence points - evaluation order unspecified.</td>
  </tr>
  <tr>
    <td width=5%>0401</td>
    <td width=95%> [U] '%s' may be modified more than once between sequence points - evaluation order unspecified.</td>
  </tr>
  <tr>
    <td width=5%>0402</td>
    <td width=95%> [U] '%s' is modified and accessed between sequence points - evaluation order unspecified.</td>
  </tr>
  <tr>
    <td width=5%>0403</td>
    <td width=95%> [U] '%s' may be modified and accessed between sequence points - evaluation order unspecified.</td>
  </tr>
  <tr>
    <td width=5%>0404</td>
    <td width=95%> More than one read access to volatile objects between sequence points.</td>
  </tr>
  <tr>
    <td width=5%>0405</td>
    <td width=95%> More than one modification of volatile objects between sequence points.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-13.3</td>
    <td width=2%>Advisory</td>
    <td width=50%>A full expression containing an increment (++) or decrement (--) operator should have no other potential side effects other than that caused by the increment or decrement operator</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3440</td>
    <td width=95%> Using the value resulting from a ++ or -- operation.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-13.4</td>
    <td width=2%>Advisory</td>
    <td width=50%>The result of an assignment operator should not be used</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3226</td>
    <td width=95%> The result of an assignment is being used in an arithmetic operation or another assigning operation.</td>
  </tr>
  <tr>
    <td width=5%>3326</td>
    <td width=95%> The result of an assignment is being used in a logical operation.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-13.5</td>
    <td width=2%>Required</td>
    <td width=50%>The right hand operand of a logical && or || operator shall not contain persistent side effects</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3415</td>
    <td width=95%> Right hand operand of '&&' or '||' is an expression with possible side effects.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-13.6</td>
    <td width=2%>Mandatory</td>
    <td width=50%>The operand of the sizeof operator shall not contain any expression which has potential side-effects</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0945</td>
    <td width=95%> [C99] Operand of sizeof is an expression of variable length array type with side effects.</td>
  </tr>
  <tr>
    <td width=5%>3307</td>
    <td width=95%> The operand of 'sizeof' is an expression with implied side effects, but they will not be evaluated.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-14.1</td>
    <td width=2%>Required</td>
    <td width=50%>A loop counter shall not have essentially floating type</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3339</td>
    <td width=95%> Floating point variable used as 'while' loop control variable.</td>
  </tr>
  <tr>
    <td width=5%>3340</td>
    <td width=95%> Floating point variable used as 'for' loop control variable.</td>
  </tr>
  <tr>
    <td width=5%>3342</td>
    <td width=95%> Controlling expression of 'for' loop is a floating point comparison.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-14.2</td>
    <td width=2%>Required</td>
    <td width=50%>A for loop shall be well-formed</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>2461</td>
    <td width=95%> Loop control variable in this 'for' statement, %s, has file scope.</td>
  </tr>
  <tr>
    <td width=5%>2462</td>
    <td width=95%> The variable initialized in the first expression of this 'for' statement is not the variable identified as the 'loop control variable' (%s).</td>
  </tr>
  <tr>
    <td width=5%>2463</td>
    <td width=95%> The variable incremented in the third expression of this 'for' statement is not the variable identified as the 'loop control variable' (%s).</td>
  </tr>
  <tr>
    <td width=5%>2464</td>
    <td width=95%> Loop control variable, %s, modified twice in for-loop header.</td>
  </tr>
  <tr>
    <td width=5%>2467</td>
    <td width=95%> Loop control variable in this 'for' statement, %s, is not modified inside loop.</td>
  </tr>
  <tr>
    <td width=5%>2468</td>
    <td width=95%> Loop control variable in this 'for' statement, %s, is not modified inside loop but has file scope.</td>
  </tr>
  <tr>
    <td width=5%>2469</td>
    <td width=95%> Loop control variable in this 'for' statement, %s, is modified in the body of the loop.</td>
  </tr>
  <tr>
    <td width=5%>2471</td>
    <td width=95%> Unable to identify a loop control variable.</td>
  </tr>
  <tr>
    <td width=5%>2472</td>
    <td width=95%> More than one possible loop control variable.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-14.3</td>
    <td width=2%>Required</td>
    <td width=50%>Controlling expressions shall not be invariant</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>2741</td>
    <td width=95%> This 'if' controlling expression is a constant expression and its value is 'true'.</td>
  </tr>
  <tr>
    <td width=5%>2742</td>
    <td width=95%> This 'if' controlling expression is a constant expression and its value is 'false'.</td>
  </tr>
  <tr>
    <td width=5%>2990</td>
    <td width=95%> The value of this loop controlling expression is always 'true'.</td>
  </tr>
  <tr>
    <td width=5%>2991</td>
    <td width=95%> The value of this 'if' controlling expression is always 'true'.</td>
  </tr>
  <tr>
    <td width=5%>2992</td>
    <td width=95%> The value of this 'if' controlling expression is always 'false'.</td>
  </tr>
  <tr>
    <td width=5%>2993</td>
    <td width=95%> The value of this 'do - while' loop controlling expression is always 'false'. The loop will only be executed once.</td>
  </tr>
  <tr>
    <td width=5%>2994</td>
    <td width=95%> The value of this 'while' or 'for' loop controlling expression is always 'false'. The loop will not be entered.</td>
  </tr>
  <tr>
    <td width=5%>2997</td>
    <td width=95%> The first operand of this conditional operator is always 'true'.</td>
  </tr>
  <tr>
    <td width=5%>2998</td>
    <td width=95%> The first operand of this conditional operator is always 'false'.</td>
  </tr>
  <tr>
    <td width=5%>3493</td>
    <td width=95%> The first operand of this conditional operator is always constant 'true'.</td>
  </tr>
  <tr>
    <td width=5%>3494</td>
    <td width=95%> The first operand of this conditional operator is always constant 'false'.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-14.4</td>
    <td width=2%>Required</td>
    <td width=50%>The controlling expression of an if-statement and the controlling expression of an iteration-statement shall have essentially Boolean type</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3344</td>
    <td width=95%> Controlling expression is not an 'essentially Boolean' expression.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-15.1</td>
    <td width=2%>Advisory</td>
    <td width=50%>The goto statement should not be used</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>2001</td>
    <td width=95%> A 'goto' statement has been used.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-15.2</td>
    <td width=2%>Required</td>
    <td width=50%>The goto statement shall jump to a label declared later in the same function</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3310</td>
    <td width=95%> This 'goto' statement involves a backward jump.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-15.3</td>
    <td width=2%>Required</td>
    <td width=50%>Any label referenced by a goto statement shall be declared in the same block, or in any block enclosing the goto statement</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3327</td>
    <td width=95%> This goto statement references a label that is declared in a separate block.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-15.4</td>
    <td width=2%>Advisory</td>
    <td width=50%>There should be no more than one break or goto statement used to terminate any iteration statement</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0771</td>
    <td width=95%> More than one 'break' statement has been used to terminate this iteration statement.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-15.5</td>
    <td width=2%>Advisory</td>
    <td width=50%>A function should have a single point of exit at the end</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>2889</td>
    <td width=95%> This function has more than one 'return' path.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-15.6</td>
    <td width=2%>Required</td>
    <td width=50%>The body of an iteration-statement or a selection-statement shall be a compound-statement</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>2212</td>
    <td width=95%> Body of control statement is not enclosed within braces.</td>
  </tr>
  <tr>
    <td width=5%>2214</td>
    <td width=95%> Body of control statement is on the same line and is not enclosed within braces.</td>
  </tr>
  <tr>
    <td width=5%>2218</td>
    <td width=95%> Body of switch statement is not enclosed within braces.</td>
  </tr>
  <tr>
    <td width=5%>2219</td>
    <td width=95%> Body of switch statement is on the same line and is not enclosed within braces.</td>
  </tr>
  <tr>
    <td width=5%>3402</td>
    <td width=95%> Braces are needed to clarify the structure of this 'if'-'if'-'else' statement.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-15.7</td>
    <td width=2%>Required</td>
    <td width=50%>All if ... else if constructs shall be terminated with an else statement</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>2004</td>
    <td width=95%> No concluding 'else' exists in this 'if'-'else'-'if' statement.</td>
  </tr>
  <tr>
    <td width=5%>2013</td>
    <td width=95%> This 'if .. else if ' construct 'else' statement is empty.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-16.1</td>
    <td width=2%>Required</td>
    <td width=50%>All switch statements shall be well-formed</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>2008</td>
    <td width=95%> Code statements precede the first label in this 'switch' construct.</td>
  </tr>
  <tr>
    <td width=5%>3234</td>
    <td width=95%> Declarations precede the first label in this 'switch' construct.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-16.2</td>
    <td width=2%>Required</td>
    <td width=50%>A switch label shall only be used when the most closely-enclosing compound statement is the body of a switch statement</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>2019</td>
    <td width=95%> 'Switch' label is located within a nested code block.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-16.3</td>
    <td width=2%>Required</td>
    <td width=50%>An unconditional break statement shall terminate every switch-clause</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>2003</td>
    <td width=95%> The preceding 'switch' clause is not empty and does not end with a 'jump' statement. Execution will fall through.</td>
  </tr>
  <tr>
    <td width=5%>2020</td>
    <td width=95%> Final 'switch' clause does not end with an explicit 'jump' statement.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-16.4</td>
    <td width=2%>Required</td>
    <td width=50%>Every switch statement shall have a default label</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>2002</td>
    <td width=95%> No 'default' label found in this 'switch' statement.</td>
  </tr>
  <tr>
    <td width=5%>2016</td>
    <td width=95%> This 'switch' statement 'default' clause is empty.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-16.5</td>
    <td width=2%>Required</td>
    <td width=50%>A default label shall appear as either the first or the last switch label of a switch statement</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>2012</td>
    <td width=95%> This 'default' label is neither the first nor the last label within the 'switch' block.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-16.6</td>
    <td width=2%>Required</td>
    <td width=50%>Every switch statement shall have at least two switch-clauses</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3315</td>
    <td width=95%> This 'switch' statement is redundant.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-16.7</td>
    <td width=2%>Required</td>
    <td width=50%>A switch-expression shall not have essentially Boolean type</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0735</td>
    <td width=95%> Switch expression is of essentially Boolean type.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-17.1</td>
    <td width=2%>Required</td>
    <td width=50%>The features of <stdarg.h> shall not be used</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>5130</td>
    <td width=95%> Use of standard header file <stdarg.h>.</td>
  </tr>
  <tr>
    <td width=5%>1337</td>
    <td width=95%> Function defined with a variable number of parameters.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-17.2</td>
    <td width=2%>Required</td>
    <td width=50%>Functions shall not call themselves, either directly or indirectly</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3670</td>
    <td width=95%> Recursive call to function containing this call.</td>
  </tr>
  <tr>
    <td width=5%>1520</td>
    <td width=95%> Functions are indirectly recursive.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-17.3</td>
    <td width=2%>Mandatory</td>
    <td width=50%>A function shall not be declared implicitly</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3335</td>
    <td width=95%> No function declaration. Implicit declaration inserted: 'extern int %s();'.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-17.4</td>
    <td width=2%>Mandatory</td>
    <td width=50%>All exit paths from a function with non-void return type shall have an explicit return statement with an expression</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0745</td>
    <td width=95%> [U] 'return;' found in '%s()', which has been defined with a non-'void' return type.</td>
  </tr>
  <tr>
    <td width=5%>2887</td>
    <td width=95%> Function 'main' ends with an implicit 'return' statement.</td>
  </tr>
  <tr>
    <td width=5%>2888</td>
    <td width=95%> This function has been declared with a non-void 'return' type but ends with an implicit 'return ;' statement.</td>
  </tr>
  <tr>
    <td width=5%>3113</td>
    <td width=95%> [U] 'return' statement includes no expression but function '%s()' is implicitly of type 'int'.</td>
  </tr>
  <tr>
    <td width=5%>3114</td>
    <td width=95%> [U] Function '%s()' is implicitly of type 'int' but ends without returning a value.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-17.5</td>
    <td width=2%>Advisory</td>
    <td width=50%>The function argument corresponding to a parameter declared to have an array type shall have an appropriate number of elements</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>2781</td>
    <td width=95%> Definite: Function argument has fewer elements than the array dimension in the parameter declaration for non-inlined call.</td>
  </tr>
  <tr>
    <td width=5%>2782</td>
    <td width=95%> Apparent: Function argument has fewer elements than the array dimension in the parameter declaration for non-inlined call.</td>
  </tr>
  <tr>
    <td width=5%>2783</td>
    <td width=95%> Suspicious: Function argument has fewer elements than the array dimension in the parameter declaration for non-inlined call.</td>
  </tr>
  <tr>
    <td width=5%>2784</td>
    <td width=95%> Possible: Function argument has fewer elements than the array dimension in the parameter declaration for non-inlined call.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-17.6</td>
    <td width=2%>Mandatory</td>
    <td width=50%>The declaration of an array parameter shall not contain the static keyword between the [ ]</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>1058</td>
    <td width=95%> [C99] The keyword 'static' is used in the declaration of a function parameter of array type.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-17.7</td>
    <td width=2%>Required</td>
    <td width=50%>The value returned by a function having non-void return type shall be used</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3200</td>
    <td width=95%> '%s' returns a value which is not being used.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-17.8</td>
    <td width=2%>Advisory</td>
    <td width=50%>A function parameter should not be modified</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>1338</td>
    <td width=95%> The parameter '%s' is being modified.</td>
  </tr>
  <tr>
    <td width=5%>1339</td>
    <td width=95%> Evaluating the address of the parameter '%s'.</td>
  </tr>
  <tr>
    <td width=5%>1340</td>
    <td width=95%> Storing the address of the parameter '%s' in a constant pointer.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-18.1</td>
    <td width=2%>Required</td>
    <td width=50%>A pointer resulting from arithmetic on a pointer operand shall address an element of the same array as that pointer operand</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>2840</td>
    <td width=95%> Constant: Dereference of an invalid pointer value.</td>
  </tr>
  <tr>
    <td width=5%>2841</td>
    <td width=95%> Definite: Dereference of an invalid pointer value.</td>
  </tr>
  <tr>
    <td width=5%>2842</td>
    <td width=95%> Apparent: Dereference of an invalid pointer value.</td>
  </tr>
  <tr>
    <td width=5%>2930</td>
    <td width=95%> Constant: Computing an invalid pointer value.</td>
  </tr>
  <tr>
    <td width=5%>2931</td>
    <td width=95%> Definite: Computing an invalid pointer value.</td>
  </tr>
  <tr>
    <td width=5%>2932</td>
    <td width=95%> Apparent: Computing an invalid pointer value.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-18.2</td>
    <td width=2%>Required</td>
    <td width=50%>Subtraction between pointers shall only be applied to pointers that address elements of the same array</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>2668</td>
    <td width=95%> Subtraction of a pointer to an array and a pointer to a non array.</td>
  </tr>
  <tr>
    <td width=5%>2761</td>
    <td width=95%> Definite: Subtracting pointers that address different objects.</td>
  </tr>
  <tr>
    <td width=5%>2762</td>
    <td width=95%> Apparent: Subtracting pointers that address different objects.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-18.3</td>
    <td width=2%>Required</td>
    <td width=50%>The relational operators >, >=, < and <= shall not be applied to objects of pointer type except where they point into the same object</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>2669</td>
    <td width=95%> Comparison of a pointer to an array and a pointer to a non array.</td>
  </tr>
  <tr>
    <td width=5%>2771</td>
    <td width=95%> Definite: Comparing pointers that address different objects.</td>
  </tr>
  <tr>
    <td width=5%>2772</td>
    <td width=95%> Apparent: Comparing pointers that address different objects.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-18.4</td>
    <td width=2%>Advisory</td>
    <td width=50%>The +, -, += and -= operators should not be applied to an expression of pointer type</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0488</td>
    <td width=95%> Performing pointer arithmetic.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-18.5</td>
    <td width=2%>Advisory</td>
    <td width=50%>Declarations should contain no more than two levels of pointer nesting</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3260</td>
    <td width=95%> Typedef defined with more than 2 levels of indirection.</td>
  </tr>
  <tr>
    <td width=5%>3261</td>
    <td width=95%> Member of struct/union defined with more than 2 levels of indirection.</td>
  </tr>
  <tr>
    <td width=5%>3262</td>
    <td width=95%> Object defined or declared with more than 2 levels of indirection.</td>
  </tr>
  <tr>
    <td width=5%>3263</td>
    <td width=95%> Function defined or declared with a return type which has more than 2 levels of indirection.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-18.6</td>
    <td width=2%>Required</td>
    <td width=50%>The address of an object with automatic storage shall not be copied to another object that persists after the first object has ceased to exist</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3217</td>
    <td width=95%> Address of automatic object exported to a pointer with linkage or wider scope.</td>
  </tr>
  <tr>
    <td width=5%>3225</td>
    <td width=95%> Address of automatic object exported using a function parameter.</td>
  </tr>
  <tr>
    <td width=5%>3230</td>
    <td width=95%> Address of automatic object assigned to local pointer with static storage duration.</td>
  </tr>
  <tr>
    <td width=5%>4140</td>
    <td width=95%> Address of automatic object exported in function return value.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-18.7</td>
    <td width=2%>Required</td>
    <td width=50%>Flexible array members shall not be declared</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>1060</td>
    <td width=95%> [C99] A flexible array member has been declared.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-18.8</td>
    <td width=2%>Required</td>
    <td width=50%>Variable-length array types shall not be used</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>1051</td>
    <td width=95%> [C99] A variable length array has been declared.</td>
  </tr>
  <tr>
    <td width=5%>1052</td>
    <td width=95%> [C99] A variable length array of unspecified size has been declared.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-19.1</td>
    <td width=2%>Mandatory</td>
    <td width=50%>An object shall not be assigned or copied to an overlapping object</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0681</td>
    <td width=95%> [U] Assignment between two incompatible members of the same union.</td>
  </tr>
  <tr>
    <td width=5%>2776</td>
    <td width=95%> Definite: Copy between overlapping objects.</td>
  </tr>
  <tr>
    <td width=5%>2777</td>
    <td width=95%> Apparent: Copy between overlapping objects.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-19.2</td>
    <td width=2%>Advisory</td>
    <td width=50%>The union keyword should not be used</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0750</td>
    <td width=95%> A union type specifier has been defined.</td>
  </tr>
  <tr>
    <td width=5%>0759</td>
    <td width=95%> An object of union type has been defined.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-2.1</td>
    <td width=2%>Required</td>
    <td width=50%>A project shall not contain unreachable code</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0594</td>
    <td width=95%> Negative 'case' label expression is incompatible with unsigned controlling expression in 'switch' statement.</td>
  </tr>
  <tr>
    <td width=5%>1460</td>
    <td width=95%> 'Switch' label value, %s, not contained in enum type.</td>
  </tr>
  <tr>
    <td width=5%>2744</td>
    <td width=95%> This 'while' or 'for' loop controlling expression is a constant expression and its value is 'false'. The loop will not be entered.</td>
  </tr>
  <tr>
    <td width=5%>2880</td>
    <td width=95%> This code is unreachable.</td>
  </tr>
  <tr>
    <td width=5%>2882</td>
    <td width=95%> This 'switch' statement will bypass the initialization of local variables.</td>
  </tr>
  <tr>
    <td width=5%>3219</td>
    <td width=95%> Static function '%s()' is not used within this translation unit.</td>
  </tr>
  <tr>
    <td width=5%>1503</td>
    <td width=95%> The function '%1s' is defined but is not used within this project.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-2.2</td>
    <td width=2%>Required</td>
    <td width=50%>There shall be no dead code</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>2980</td>
    <td width=95%> The value of this function parameter is never used before being modified.</td>
  </tr>
  <tr>
    <td width=5%>2981</td>
    <td width=95%> This initialization is redundant. The value of this object is never used before being modified.</td>
  </tr>
  <tr>
    <td width=5%>2982</td>
    <td width=95%> This assignment is redundant. The value of this object is never used before being modified.</td>
  </tr>
  <tr>
    <td width=5%>2983</td>
    <td width=95%> This assignment is redundant. The value of this object is never subsequently used.</td>
  </tr>
  <tr>
    <td width=5%>2985</td>
    <td width=95%> This operation is redundant. The value of the result is always that of the left-hand operand.</td>
  </tr>
  <tr>
    <td width=5%>2986</td>
    <td width=95%> This operation is redundant. The value of the result is always that of the right-hand operand.</td>
  </tr>
  <tr>
    <td width=5%>2987</td>
    <td width=95%> This function call produces no side effects and is redundant.</td>
  </tr>
  <tr>
    <td width=5%>2995</td>
    <td width=95%> The result of this logical operation is always 'true'.</td>
  </tr>
  <tr>
    <td width=5%>2996</td>
    <td width=95%> The result of this logical operation is always 'false'.</td>
  </tr>
  <tr>
    <td width=5%>3110</td>
    <td width=95%> The left-hand operand of this ',' has no side effects.</td>
  </tr>
  <tr>
    <td width=5%>3112</td>
    <td width=95%> This statement has no side-effect - it can be removed.</td>
  </tr>
  <tr>
    <td width=5%>3404</td>
    <td width=95%> Statement contains a redundant * operator at top level. *p++ means *(p++) not (*p)++.</td>
  </tr>
  <tr>
    <td width=5%>3422</td>
    <td width=95%> Statement contains a redundant operator at top level.</td>
  </tr>
  <tr>
    <td width=5%>3423</td>
    <td width=95%> Statement contains a redundant cast at top level.</td>
  </tr>
  <tr>
    <td width=5%>3424</td>
    <td width=95%> Statement contains a redundant & or | at top level.</td>
  </tr>
  <tr>
    <td width=5%>3425</td>
    <td width=95%> One branch of this conditional operation is a redundant expression.</td>
  </tr>
  <tr>
    <td width=5%>3426</td>
    <td width=95%> Right hand side of comma expression has no side effect and its value is not used.</td>
  </tr>
  <tr>
    <td width=5%>3427</td>
    <td width=95%> Right hand side of logical operator has no side effect and its value is not used.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-2.3</td>
    <td width=2%>Advisory</td>
    <td width=50%>A project should not contain unused type declarations</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3205</td>
    <td width=95%> The identifier '%s' is not used and could be removed.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-2.4</td>
    <td width=2%>Advisory</td>
    <td width=50%>A project should not contain unused tag declarations</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3213</td>
    <td width=95%> The tag '%s' is not used and could be removed.</td>
  </tr>
  <tr>
    <td width=5%>1755</td>
    <td width=95%> The tag '%1s' is declared but not used within this project.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-2.5</td>
    <td width=2%>Advisory</td>
    <td width=50%>A project should not contain unused macro declarations</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3214</td>
    <td width=95%> The macro '%s' is not used and could be removed.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-2.6</td>
    <td width=2%>Advisory</td>
    <td width=50%>A function should not contain unused label declarations</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3202</td>
    <td width=95%> The label '%s:' is not used in this function and could be removed.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-2.7</td>
    <td width=2%>Advisory</td>
    <td width=50%>There should be no unused parameters in functions</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3206</td>
    <td width=95%> The parameter '%s' is not used in this function.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-20.1</td>
    <td width=2%>Advisory</td>
    <td width=50%>#include directives should only be preceded by preprocessor directives or comments</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>5087</td>
    <td width=95%> Use of #include directive after code fragment.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-20.10</td>
    <td width=2%>Advisory</td>
    <td width=50%>The # and ## preprocessor operators should not be used</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0341</td>
    <td width=95%> Using the stringify operator '#'.</td>
  </tr>
  <tr>
    <td width=5%>0342</td>
    <td width=95%> Using the glue operator '##'.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-20.11</td>
    <td width=2%>Required</td>
    <td width=50%>A macro parameter immediately following a # operator shall not immediately be followed by a ## operator</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0892</td>
    <td width=95%> This macro parameter is preceded by '#' and followed by '##'.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-20.12</td>
    <td width=2%>Required</td>
    <td width=50%>A macro parameter used as an operand to the # or ## operators, which is itself subject to further macro replacement, shall only be used as an operand to these operators</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0893</td>
    <td width=95%> Macro parameter '%s' is inconsistently subject to macro replacement.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-20.13</td>
    <td width=2%>Required</td>
    <td width=50%>A line whose first token is # shall be a valid preprocessing directive</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3115</td>
    <td width=95%> Unrecognized preprocessing directive has been ignored because of conditional inclusion directives.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-20.14</td>
    <td width=2%>Required</td>
    <td width=50%>All #else, #elif and #endif preprocessor directives shall reside in the same file as the #if, #ifdef or #ifndef directive to which they are related</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3317</td>
    <td width=95%> '#if...' not matched by '#endif' in included file. This is probably an error.</td>
  </tr>
  <tr>
    <td width=5%>3318</td>
    <td width=95%> '#else'/'#elif'/'#endif' in included file matched '#if...' in parent file. This is probably an error.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-20.2</td>
    <td width=2%>Required</td>
    <td width=50%>The ', " or \ characters and the /* or // character sequences shall not occur in a header file name</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0813</td>
    <td width=95%> [U] Using any of the characters ' " or /* in '#include <%s>' gives undefined behaviour.</td>
  </tr>
  <tr>
    <td width=5%>0814</td>
    <td width=95%> [U] Using the characters ' or /* in '#include "%s"' gives undefined behaviour.</td>
  </tr>
  <tr>
    <td width=5%>0831</td>
    <td width=95%> [E] Use of '\\' in this '#include' line is a PC extension - this usage is non-portable.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-20.3</td>
    <td width=2%>Required</td>
    <td width=50%>The #include directive shall be followed by either a <filename> or "filename" sequence</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0817</td>
    <td width=95%> [S] Closing quote or bracket '>' missing from include filename.</td>
  </tr>
  <tr>
    <td width=5%>0821</td>
    <td width=95%> [C] '#include' does not identify a header or source file that can be processed.</td>
  </tr>
  <tr>
    <td width=5%>0840</td>
    <td width=95%> [E] Extra tokens at end of #include directive.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-20.4</td>
    <td width=2%>Required</td>
    <td width=50%>A macro shall not be defined with the same name as a keyword</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3439</td>
    <td width=95%> Macro redefines a keyword.</td>
  </tr>
  <tr>
    <td width=5%>3468</td>
    <td width=95%> The name of this macro is a reserved identifier in C90 and a keyword in C99.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-20.5</td>
    <td width=2%>Advisory</td>
    <td width=50%>#undef should not be used</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0841</td>
    <td width=95%> Using '#undef'.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-20.6</td>
    <td width=2%>Required</td>
    <td width=50%>Tokens that look like a preprocessing directive shall not occur within a macro argument</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0853</td>
    <td width=95%> [U] Macro arguments contain a sequence of tokens that has the form of a preprocessing directive.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-20.7</td>
    <td width=2%>Required</td>
    <td width=50%>Expressions resulting from the expansion of macro parameters shall be enclosed in parentheses</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3430</td>
    <td width=95%> Macro argument expression may require parentheses.</td>
  </tr>
  <tr>
    <td width=5%>3432</td>
    <td width=95%> Simple macro argument expression is not parenthesized.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-20.8</td>
    <td width=2%>Required</td>
    <td width=50%>The controlling expression of a #if or #elif preprocessing directive shall evaluate to 0 or 1</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0894</td>
    <td width=95%> '#%s' directive controlling expression does not evaluate to zero or one.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-20.9</td>
    <td width=2%>Required</td>
    <td width=50%>All identifiers used in the controlling expression of #if or #elif preprocessing directives shall be #define'd before evaluation</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3332</td>
    <td width=95%> The macro '%s' used in this '#if' or '#elif' expression is not defined.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-21.1</td>
    <td width=2%>Required</td>
    <td width=50%>#define and #undef shall not be used on a reserved identifier or reserved macro name</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0603</td>
    <td width=95%> [U] The macro identifier '%s' is reserved.</td>
  </tr>
  <tr>
    <td width=5%>0836</td>
    <td width=95%> [U] Definition of macro named 'defined'.</td>
  </tr>
  <tr>
    <td width=5%>0848</td>
    <td width=95%> [U] Attempting to #undef '%s', which is a predefined macro name.</td>
  </tr>
  <tr>
    <td width=5%>0854</td>
    <td width=95%> [U] Attempting to #define '%s', which is a predefined macro name.</td>
  </tr>
  <tr>
    <td width=5%>4600</td>
    <td width=95%> The macro '%1s' is also defined in '<%2s>'.</td>
  </tr>
  <tr>
    <td width=5%>4601</td>
    <td width=95%> The macro '%1s' is the name of an identifier in '<%2s>'.</td>
  </tr>
  <tr>
    <td width=5%>4620</td>
    <td width=95%> The macro '%1s' may also be defined as a macro in '<%2s>'.</td>
  </tr>
  <tr>
    <td width=5%>4621</td>
    <td width=95%> The macro '%1s' may also be defined as a typedef in '<%2s>'.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-21.10</td>
    <td width=2%>Required</td>
    <td width=50%>The Standard Library time and date functions shall not be used</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>5127</td>
    <td width=95%> Use of standard header file <time.h>.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-21.11</td>
    <td width=2%>Required</td>
    <td width=50%>The standard header file <tgmath.h> shall not be used</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>5131</td>
    <td width=95%> Use of standard header file <tgmath.h>.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-21.12</td>
    <td width=2%>Advisory</td>
    <td width=50%>The exception handling features of <fenv.h> should not be used</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>5136</td>
    <td width=95%> Use of exception handling identifier: feclearexcept, fegetexceptflag, feraiseexcept, fesetexceptflag or fetestexcept.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-21.13</td>
    <td width=2%>Mandatory</td>
    <td width=50%>Any value passed to a function in <ctype.h> shall be representable as an unsigned char or be the value EOF</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>2796</td>
    <td width=95%> Definite: Calling a standard library character handling function with an invalid character value.</td>
  </tr>
  <tr>
    <td width=5%>2797</td>
    <td width=95%> Apparent: Calling a standard library character handling function with an invalid character value.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-21.14</td>
    <td width=2%>Required</td>
    <td width=50%>The Standard Library function memcmp shall not be used to compare null terminated strings</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>2785</td>
    <td width=95%> Constant: Null terminated string is being passed as argument to Standard Library function memcmp.</td>
  </tr>
  <tr>
    <td width=5%>2786</td>
    <td width=95%> Definite: Null terminated string is being passed as argument to Standard Library function memcmp.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-21.15</td>
    <td width=2%>Required</td>
    <td width=50%>The pointer arguments to the Standard Library functions memcpy, memmove and memcmp shall be pointers to qualified or unqualified versions of compatible types</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>1487</td>
    <td width=95%> Comparing the representations of objects of different types.</td>
  </tr>
  <tr>
    <td width=5%>1495</td>
    <td width=95%> Destination and source objects have incompatible types.</td>
  </tr>
  <tr>
    <td width=5%>1496</td>
    <td width=95%> Destination and source objects may have incompatible types.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-21.16</td>
    <td width=2%>Required</td>
    <td width=50%>The pointer arguments to the Standard Library function memcpy shall point to either a pointer type, an essentially signed type, an essentially unsigned type, an essentially Boolean type or an essentially enum type</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>1488</td>
    <td width=95%> Comparison of a struct object representation.</td>
  </tr>
  <tr>
    <td width=5%>1489</td>
    <td width=95%> Comparison of a union object representation.</td>
  </tr>
  <tr>
    <td width=5%>1490</td>
    <td width=95%> Comparison of a floating point object representation.</td>
  </tr>
  <tr>
    <td width=5%>1491</td>
    <td width=95%> Comparison of an object representation.</td>
  </tr>
  <tr>
    <td width=5%>1497</td>
    <td width=95%> Comparison of a string object representation.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-21.17</td>
    <td width=2%>Mandatory</td>
    <td width=50%>Use of the string handling functions from <string.h> shall not result in accesses beyond the bounds of the objects referenced by their pointer parameters</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>2835</td>
    <td width=95%> Constant: Non null terminated string used in a string function.</td>
  </tr>
  <tr>
    <td width=5%>2836</td>
    <td width=95%> Definite: Non null terminated string used in a string function.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-21.18</td>
    <td width=2%>Mandatory</td>
    <td width=50%>The size_t argument passed to any function in <string.h> shall have an appropriate value</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>2840</td>
    <td width=95%> Constant: Dereference of an invalid pointer value.</td>
  </tr>
  <tr>
    <td width=5%>2841</td>
    <td width=95%> Definite: Dereference of an invalid pointer value.</td>
  </tr>
  <tr>
    <td width=5%>2842</td>
    <td width=95%> Apparent: Dereference of an invalid pointer value.</td>
  </tr>
  <tr>
    <td width=5%>2865</td>
    <td width=95%> Constant: Using 0 as size parameter of a function call.</td>
  </tr>
  <tr>
    <td width=5%>2866</td>
    <td width=95%> Definite: Using 0 as size parameter of a function call.</td>
  </tr>
  <tr>
    <td width=5%>2867</td>
    <td width=95%> Apparent: Using 0 as size parameter of a function call.</td>
  </tr>
  <tr>
    <td width=5%>2868</td>
    <td width=95%> Suspicious: Using 0 as size parameter of a function call.</td>
  </tr>
  <tr>
    <td width=5%>2869</td>
    <td width=95%> Possible: Using 0 as size parameter of a function call.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-21.19</td>
    <td width=2%>Mandatory</td>
    <td width=50%>The pointers returned by the Standard Library functions lovaleconv, getenv, setlocale or strerror shall only be used as if they have pointer to const-qualified type</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>1492</td>
    <td width=95%> The result of library function '%s' is used to modify the referenced object.</td>
  </tr>
  <tr>
    <td width=5%>1493</td>
    <td width=95%> The result of library function '%s' is used as a pointer to a modifiable object.</td>
  </tr>
  <tr>
    <td width=5%>1494</td>
    <td width=95%> The result of library function '%s' might be modified.</td>
  </tr>
  <tr>
    <td width=5%>1498</td>
    <td width=95%> The string referenced by <locale.h> type 'struct lconv' member '%s' is being modified.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-21.2</td>
    <td width=2%>Required</td>
    <td width=50%>A reserved identifier or macro name shall not be declared</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0602</td>
    <td width=95%> [U] The identifier '%s' is reserved for use by the library.</td>
  </tr>
  <tr>
    <td width=5%>4602</td>
    <td width=95%> The identifier '%1s' is declared as a macro in '<%2s>'.</td>
  </tr>
  <tr>
    <td width=5%>4603</td>
    <td width=95%> The object/function '%1s'is being defined with the same name as an ordinary identifier defined in '<%2s>'.</td>
  </tr>
  <tr>
    <td width=5%>4604</td>
    <td width=95%> The object/function '%1s' is being declared with the same name as an ordinary identifier defined in '<%2s>'.</td>
  </tr>
  <tr>
    <td width=5%>4605</td>
    <td width=95%> The typedef '%1s' is also defined in '<%2s>'.</td>
  </tr>
  <tr>
    <td width=5%>4606</td>
    <td width=95%> The typedef '%1s' has the same name as another ordinary identifier in '<%2s>'.</td>
  </tr>
  <tr>
    <td width=5%>4607</td>
    <td width=95%> The enum constant '%1s' has the same name as another ordinary identifier in '<%2s>'.</td>
  </tr>
  <tr>
    <td width=5%>4608</td>
    <td width=95%> The tag '%1s' is also defined in '<%2s>'.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-21.20</td>
    <td width=2%>Mandatory</td>
    <td width=50%>The pointer returned by the Standard Library functions asctime, ctime, gmtime, localtime, localeconv, getenv, setlocale, or strerror shall not be used following a subsequent call to the same function</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>2681</td>
    <td width=95%> Definite: Using an invalidated value '%s' returned from a Standard Library function.</td>
  </tr>
  <tr>
    <td width=5%>2682</td>
    <td width=95%> Apparent: Using an invalidated value '%s' returned from a Standard Library function.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-21.3</td>
    <td width=2%>Required</td>
    <td width=50%>The memory allocation and deallocation functions of <stdlib.h> shall not be used</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>5118</td>
    <td width=95%> Use of memory allocation or deallocation function: calloc, malloc, realloc or free.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-21.4</td>
    <td width=2%>Required</td>
    <td width=50%>The standard header file <setjmp.h> shall not be used</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>5132</td>
    <td width=95%> Use of standard header file <setjmp.h>.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-21.5</td>
    <td width=2%>Required</td>
    <td width=50%>The standard header file <signal.h> shall not be used</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>5123</td>
    <td width=95%> Use of standard header file <signal.h>.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-21.6</td>
    <td width=2%>Required</td>
    <td width=50%>The Standard Library input/output functions shall not be used</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>5124</td>
    <td width=95%> The Standard Library input/output functions shall not be used</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-21.7</td>
    <td width=2%>Required</td>
    <td width=50%>The atof, atoi, atol and atoll functions of <stdlib.h> shall not be used</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>5125</td>
    <td width=95%> Use of function: atof, atoi, atol or atoll.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-21.8</td>
    <td width=2%>Required</td>
    <td width=50%>The library functions abort, exit and system of <stdlib.h> shall not be used</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>5126</td>
    <td width=95%> Use of function: abort, exit or system.</td>
  </tr>
  <tr>
    <td width=5%>5128</td>
    <td width=95%> Use of function: getenv.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-21.9</td>
    <td width=2%>Required</td>
    <td width=50%>The library functions bsearch and qsort of <stdlib.h> shall not be used</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>5135</td>
    <td width=95%> Use of function: bsearch or qsort.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-22.1</td>
    <td width=2%>Required</td>
    <td width=50%>All resources obtained dynamically by means of Standard Library functions shall be explicitly released</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>2701</td>
    <td width=95%> Definite: Opened file is not closed.</td>
  </tr>
  <tr>
    <td width=5%>2702</td>
    <td width=95%> Apparent: Opened file is not closed.</td>
  </tr>
  <tr>
    <td width=5%>2706</td>
    <td width=95%> Definite: Allocated memory is not deallocated.</td>
  </tr>
  <tr>
    <td width=5%>2707</td>
    <td width=95%> Apparent: Allocated memory is not deallocated.</td>
  </tr>
  <tr>
    <td width=5%>2736</td>
    <td width=95%> Definite: Created resource is not destroyed.</td>
  </tr>
  <tr>
    <td width=5%>2737</td>
    <td width=95%> Apparent: Created resource is not destroyed.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-22.10</td>
    <td width=2%>Required</td>
    <td width=50%>The value of errno shall only be tested when the last function to be called was an errno-setting-function</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>2503</td>
    <td width=95%> Testing of 'errno' is not immediately preceded by a call to an 'errno' setting function.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-22.2</td>
    <td width=2%>Mandatory</td>
    <td width=50%>A block of memory shall only be freed if it was allocated by means of a Standard Library function</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>2721</td>
    <td width=95%> Definite: Deallocation of non dynamic memory.</td>
  </tr>
  <tr>
    <td width=5%>2722</td>
    <td width=95%> Apparent: Deallocation of non dynamic memory.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-22.3</td>
    <td width=2%>Required</td>
    <td width=50%>The same file shall not be open for read and write access at the same time on different streams</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>2691</td>
    <td width=95%> Definite: The same file will be open with write access and another mode.</td>
  </tr>
  <tr>
    <td width=5%>2692</td>
    <td width=95%> Apparent: The same file will be open with write access and another mode.</td>
  </tr>
  <tr>
    <td width=5%>2693</td>
    <td width=95%> Suspicious: The same file will be open with write access and another mode.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-22.4</td>
    <td width=2%>Mandatory</td>
    <td width=50%>There shall be no attempt to write to a stream which has been opened as read-only</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>2686</td>
    <td width=95%> Definite: Writing to a file opened for reading.</td>
  </tr>
  <tr>
    <td width=5%>2687</td>
    <td width=95%> Apparent: Writing to a file opened for reading.</td>
  </tr>
  <tr>
    <td width=5%>2688</td>
    <td width=95%> Suspicious: Writing to a file opened for reading.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-22.5</td>
    <td width=2%>Mandatory</td>
    <td width=50%>A pointer to a FILE object shall not be dereferenced</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>1485</td>
    <td width=95%> A pointer to a FILE object is dereferenced.</td>
  </tr>
  <tr>
    <td width=5%>1486</td>
    <td width=95%> A pointer to a FILE object is converted to a different type.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-22.6</td>
    <td width=2%>Mandatory</td>
    <td width=50%>The value of a pointer to a FILE shall not be used after the associated stream has been closed</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>2696</td>
    <td width=95%> Definite: Attempt to access a file which has been closed.</td>
  </tr>
  <tr>
    <td width=5%>2697</td>
    <td width=95%> Apparent: Attempt to access a file which has been closed.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-22.7</td>
    <td width=2%>Required</td>
    <td width=50%>The macro EOF shall on ly be compared with the unmodified return value from any Standard Library function capable of returning EOF</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>2671</td>
    <td width=95%> Definite: The value being compared with macro EOF does not originate from an EOF returning function.</td>
  </tr>
  <tr>
    <td width=5%>2676</td>
    <td width=95%> Definite: The value originating from an EOF returning function was modified before being compared with macro EOF.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-22.8</td>
    <td width=2%>Required</td>
    <td width=50%>The value of errno shall be set to zero prior to a call to an errno-setting-function</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>2500</td>
    <td width=95%> Call to '%s' is not immediately preceded by the zeroing of 'errno'.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-22.9</td>
    <td width=2%>Required</td>
    <td width=50%>The value of errno shall be tested against zero after calling an errno-setting-function</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>2501</td>
    <td width=95%> Call to '%s' is not immediately followed by the testing of 'errno'.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-3.1</td>
    <td width=2%>Required</td>
    <td width=50%>The character sequences /* and // shall not be used within a comment.</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3108</td>
    <td width=95%> Nested comments are not recognized in the ISO standard.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-3.2</td>
    <td width=2%>Required</td>
    <td width=50%>Line-splicing shall not be used in // comments.</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>5134</td>
    <td width=95%> C++ style comment uses line splicing.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-4.1</td>
    <td width=2%>Required</td>
    <td width=50%>Octal and hexadecimal escape sequences shall be terminated</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3636</td>
    <td width=95%> Octal escape sequence '%s' is not terminated.</td>
  </tr>
  <tr>
    <td width=5%>3637</td>
    <td width=95%> Hexadecimal escape sequence '%s' is not terminated.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-4.2</td>
    <td width=2%>Advisory</td>
    <td width=50%>Trigraphs should not be used</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3601</td>
    <td width=95%> Trigraphs (??x) are an ISO feature.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-5.1</td>
    <td width=2%>Required</td>
    <td width=50%>External identifiers shall be distinct</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0777</td>
    <td width=95%> [U] External identifier does not differ from other identifier(s) (e.g. '%s') within the specified number of significant characters.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-5.2</td>
    <td width=2%>Required</td>
    <td width=50%>Identifiers declared in the same scope and name space shall be distinct</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0779</td>
    <td width=95%> [U] Identifier does not differ from other identifier(s) (e.g. '%s') within the specified number of significant characters.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-5.3</td>
    <td width=2%>Required</td>
    <td width=50%>An identifier declared in an inner scope shall not hide an identifier declared in an outer scope</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0795</td>
    <td width=95%> Identifier matches other identifier(s) (e.g. '%s') in an outer scope within the specified number of significant characters.</td>
  </tr>
  <tr>
    <td width=5%>2547</td>
    <td width=95%> This declaration of tag '%s' hides a more global declaration.</td>
  </tr>
  <tr>
    <td width=5%>3334</td>
    <td width=95%> This declaration of '%s' hides a more global declaration.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-5.4</td>
    <td width=2%>Required</td>
    <td width=50%>Macro identifiers shall be distinct</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0788</td>
    <td width=95%> This identifier, '%s', is used as both a macro name and a function-like macro parameter name.</td>
  </tr>
  <tr>
    <td width=5%>0791</td>
    <td width=95%> [U] Macro identifier does not differ from other macro identifier(s) (e.g. '%s') within the specified number of significant characters.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-5.5</td>
    <td width=2%>Required</td>
    <td width=50%>Identifiers shall be distinct from macro names</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0784</td>
    <td width=95%> Identifier '%s' is also used as a macro name.</td>
  </tr>
  <tr>
    <td width=5%>0785</td>
    <td width=95%> Identifier matches other macro name(s) (e.g. '%s') in first 31 characters.</td>
  </tr>
  <tr>
    <td width=5%>0786</td>
    <td width=95%> Identifier matches other macro name(s) (e.g. '%s') in first 63 characters.</td>
  </tr>
  <tr>
    <td width=5%>0787</td>
    <td width=95%> Identifier does not differ from other macro name(s) (e.g. '%s') within the specified number of significant characters.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-5.6</td>
    <td width=2%>Required</td>
    <td width=50%>A typedef name shall be a unique identifier</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>1506</td>
    <td width=95%> The identifier '%1s' is declared as a typedef and is used elsewhere for a different kind of declaration.</td>
  </tr>
  <tr>
    <td width=5%>1507</td>
    <td width=95%> '%1s' is used as a typedef for different types.</td>
  </tr>
  <tr>
    <td width=5%>1508</td>
    <td width=95%> The typedef '%1s' is declared in more than one location.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-5.7</td>
    <td width=2%>Required</td>
    <td width=50%>A tag name shall be a unique identifier</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>2547</td>
    <td width=95%> This declaration of tag '%s' hides a more global declaration.</td>
  </tr>
  <tr>
    <td width=5%>1750</td>
    <td width=95%> '%1s' has multiple definitions.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-5.8</td>
    <td width=2%>Required</td>
    <td width=50%>Identifiers that define objects or functions with external linkage shall be unique</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>1525</td>
    <td width=95%> Object/function with external linkage has same identifier as another object/function with internal linkage.</td>
  </tr>
  <tr>
    <td width=5%>1526</td>
    <td width=95%> Object with no linkage has same identifier as another object/function with external linkage.</td>
  </tr>
  <tr>
    <td width=5%>1756</td>
    <td width=95%> External identifier '%1s' shall be unique.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-5.9</td>
    <td width=2%>Advisory</td>
    <td width=50%>Identifiers that define objects or functions with internal linkage should be unique</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>1525</td>
    <td width=95%> Object/function with external linkage has same identifier as another object/function with internal linkage.</td>
  </tr>
  <tr>
    <td width=5%>1527</td>
    <td width=95%> Object/function with internal linkage has same identifier as another object/function with internal linkage.</td>
  </tr>
  <tr>
    <td width=5%>1528</td>
    <td width=95%> Object with no linkage has same identifier as another object/function with internal linkage.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-6.1</td>
    <td width=2%>Required</td>
    <td width=50%>Bit-fields shall only be declared with an appropriate type</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0634</td>
    <td width=95%> [I] Bit-fields in this struct/union have not been declared explicitly as unsigned or signed.</td>
  </tr>
  <tr>
    <td width=5%>0635</td>
    <td width=95%> [E] Bit-fields in this struct/union have been declared with types other than int, signed int, unsigned int or _Bool.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-6.2</td>
    <td width=2%>Required</td>
    <td width=50%>Single-bit named bit fields shall not be of a signed type</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3660</td>
    <td width=95%> Named bit-field consisting of a single bit declared with a signed type.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-7.1</td>
    <td width=2%>Required</td>
    <td width=50%>Octal constants shall not be used</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0336</td>
    <td width=95%> Macro defined as an octal constant.</td>
  </tr>
  <tr>
    <td width=5%>0339</td>
    <td width=95%> Octal constant used.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-7.2</td>
    <td width=2%>Required</td>
    <td width=50%>A "u" or "U" suffix shall be applied to all integer constants that are represented in an unsigned type</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>1281</td>
    <td width=95%> Integer literal constant is of an unsigned type but does not include a "U" suffix.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-7.3</td>
    <td width=2%>Required</td>
    <td width=50%>The lowercase character "l" shall not be used in a literal suffix</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>1280</td>
    <td width=95%> A lowercase letter L (l) has been used in an integer or floating suffix.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-7.4</td>
    <td width=2%>Required</td>
    <td width=50%>A string literal shall not be assigned to an object unless the object's type is "pointer to const-qualified char"</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0752</td>
    <td width=95%> String literal passed as argument to function whose parameter is not a 'pointer to const'.</td>
  </tr>
  <tr>
    <td width=5%>0753</td>
    <td width=95%> String literal assigned to pointer which is not a 'pointer to const'.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-8.1</td>
    <td width=2%>Required</td>
    <td width=50%>Types shall be explicitly specified</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>2050</td>
    <td width=95%> The 'int' type specifier has been omitted from a function declaration.</td>
  </tr>
  <tr>
    <td width=5%>2051</td>
    <td width=95%> The 'int' type specifier has been omitted from an object declaration.</td>
  </tr>
  <tr>
    <td width=5%>1525</td>
    <td width=95%> Object/function with external linkage has same identifier as another object/function with internal linkage.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-8.10</td>
    <td width=2%>Required</td>
    <td width=50%>An inline function shall be declared with the static storage class</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3240</td>
    <td width=95%> inline function '%s' is being defined with external linkage.</td>
  </tr>
  <tr>
    <td width=5%>3243</td>
    <td width=95%> inline function '%s' is also an 'external definition'.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-8.11</td>
    <td width=2%>Advisory</td>
    <td width=50%>When an array with external linkage is declared, its size should be explicitly specified</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3684</td>
    <td width=95%> Array declared with unknown size.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-8.12</td>
    <td width=2%>Required</td>
    <td width=50%>Within an enumerator list, the value of an implicitly-specified enumeration constant shall be unique</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0724</td>
    <td width=95%> The value of this implicitly-specified enumeration constant is not unique.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-8.13</td>
    <td width=2%>Advisory</td>
    <td width=50%>A pointer should point to a const-qualified type whenever possible</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3673</td>
    <td width=95%> The object addressed by the pointer parameter '%s' is not modified and so the pointer could be of type 'pointer to const'.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-8.14</td>
    <td width=2%>Required</td>
    <td width=50%>The restrict type qualifier shall not be used</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>1057</td>
    <td width=95%> [C99] The keyword 'restrict' has been used.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-8.2</td>
    <td width=2%>Required</td>
    <td width=50%>Function types shall be in prototype form with named parameters</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>1335</td>
    <td width=95%> Parameter identifiers missing in function prototype declaration.</td>
  </tr>
  <tr>
    <td width=5%>1336</td>
    <td width=95%> Parameter identifiers missing in declaration of a function type.</td>
  </tr>
  <tr>
    <td width=5%>3001</td>
    <td width=95%> Function has been declared with an empty parameter list.</td>
  </tr>
  <tr>
    <td width=5%>3002</td>
    <td width=95%> Defining '%s()' with an identifier list and separate parameter declarations is an obsolescent feature.</td>
  </tr>
  <tr>
    <td width=5%>3007</td>
    <td width=95%> "void" has been omitted when defining a function with no parameters.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-8.3</td>
    <td width=2%>Required</td>
    <td width=50%>All declarations of an object or function shall use the same names and type qualifiers</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0624</td>
    <td width=95%> Function '%s' is declared using typedefs which are different to those in a previous declaration.</td>
  </tr>
  <tr>
    <td width=5%>1330</td>
    <td width=95%> The parameter identifiers in this function declaration differ from those in a previous declaration.</td>
  </tr>
  <tr>
    <td width=5%>3675</td>
    <td width=95%> Function parameter declared with type qualification which differs from previous declaration.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-8.4</td>
    <td width=2%>Required</td>
    <td width=50%>A compatible declaration shall be visible when an object or function with external linkage is defined</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3408</td>
    <td width=95%> '%s' has external linkage and is being defined without any previous declaration.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-8.5</td>
    <td width=2%>Required</td>
    <td width=50%>An external object or function shall be declared once in one and only one file</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3449</td>
    <td width=95%> Multiple declarations of external object or function.</td>
  </tr>
  <tr>
    <td width=5%>3451</td>
    <td width=95%> The global identifier '%s' has been declared in more than one file.</td>
  </tr>
  <tr>
    <td width=5%>1513</td>
    <td width=95%> Identifier '%1s' with external linkage has separate non-defining declarations in more than one location.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-8.6</td>
    <td width=2%>Required</td>
    <td width=50%>An identifier with external linkage shall have exactly one external definition</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0630</td>
    <td width=95%> [U] More than one definition of '%s' (with external linkage).</td>
  </tr>
  <tr>
    <td width=5%>3406</td>
    <td width=95%> Object/function '%s', with external linkage, has been defined in a header file.</td>
  </tr>
  <tr>
    <td width=5%>1509</td>
    <td width=95%> '%1s' has external linkage and has multiple definitions.</td>
  </tr>
  <tr>
    <td width=5%>1752</td>
    <td width=95%> The object '%1s' with external linkage is declared but not defined within this project.</td>
  </tr>
  <tr>
    <td width=5%>1753</td>
    <td width=95%> The function '%1s' with external linkage is declared but not defined within this project.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-8.7</td>
    <td width=2%>Advisory</td>
    <td width=50%>Functions and objects should not be defined with external linkage if they are referenced in only one translation unit</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>1504</td>
    <td width=95%> The object '%1s' is only referenced in the translation unit where it is defined.</td>
  </tr>
  <tr>
    <td width=5%>1505</td>
    <td width=95%> The function '%1s' is only referenced in the translation unit where it is defined.</td>
  </tr>
  <tr>
    <td width=5%>1531</td>
    <td width=95%> The object '%1s' is referenced in only one translation unit - but not the one in which it is defined.</td>
  </tr>
  <tr>
    <td width=5%>1532</td>
    <td width=95%> The function '%1s' is only referenced in one translation unit - but not the one in which it is defined.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-8.8</td>
    <td width=2%>Required</td>
    <td width=50%>The static storage class specifier shall be used in all declarations of objects and functions that have internal linkage</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3224</td>
    <td width=95%> This identifier has previously been declared with internal linkage but is not declared here with the static storage class specifier.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-8.9</td>
    <td width=2%>Advisory</td>
    <td width=50%>An object should be defined at block scope if its identifier only appears in a single function</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3218</td>
    <td width=95%> File scope static, '%s', is only accessed in one function.</td>
  </tr>
  <tr>
    <td width=5%>1514</td>
    <td width=95%> The object '%1s' is only referenced by function '%2s', in the translation unit where it is defined</td>
  </tr>
  <tr>
    <td width=5%>1533</td>
    <td width=95%> The object '%1s' is only referenced by function '%2s'.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-9.1</td>
    <td width=2%>Mandatory</td>
    <td width=50%>The value of an object with automatic storage duration shall not be read before it has been set</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>2883</td>
    <td width=95%> This 'goto' statement will always bypass the initialization of local variables.</td>
  </tr>
  <tr>
    <td width=5%>2961</td>
    <td width=95%> Definite: Using value of uninitialized automatic object '%s'.</td>
  </tr>
  <tr>
    <td width=5%>2962</td>
    <td width=95%> Apparent: Using value of uninitialized automatic object '%s'.</td>
  </tr>
  <tr>
    <td width=5%>2971</td>
    <td width=95%> Definite: Passing address of uninitialized object '%s' to a function parameter declared as a pointer to const.</td>
  </tr>
  <tr>
    <td width=5%>2972</td>
    <td width=95%> Apparent: Passing address of uninitialized object '%s' to a function parameter declared as a pointer to const.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-9.2</td>
    <td width=2%>Required</td>
    <td width=50%>The initializer for an aggregate or union shall be enclosed in braces</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0693</td>
    <td width=95%> Struct initializer is missing the optional {.</td>
  </tr>
  <tr>
    <td width=5%>0694</td>
    <td width=95%> Array initializer is missing the optional {.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-9.3</td>
    <td width=2%>Required</td>
    <td width=50%>Arrays shall not be partially initialized</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0686</td>
    <td width=95%> Array has fewer initializers than its declared size. Default initialization is applied to the remainder of the array elements.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-9.4</td>
    <td width=2%>Required</td>
    <td width=50%>An element of an object shall not be initialized more than once</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>1397</td>
    <td width=95%> Array element '%s' has already been initialized.</td>
  </tr>
  <tr>
    <td width=5%>1398</td>
    <td width=95%> Structure member '%s' has already been initialized.</td>
  </tr>
  <tr>
    <td width=5%>1399</td>
    <td width=95%> A union member has already been initialized.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>                                           
    <td width=2%>Rule-9.5</td>
    <td width=2%>Required</td>
    <td width=50%>Where designated initializers are used to initialize an array object the size of the array shall be specified explicitly</td>
    <td><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3676</td>
    <td width=95%> Designators are used to initialize an array of unspecified size.</td>
  </tr>
</table></center>
</td>
  </tr>
</table></center>
</div>
<div class="GRP">
<div class="sec"><h2><a name="GRP">GRP - Guideline Recategorization Plan</a></h2></div>
This section targets to provide an overview of Guidelines Recategorization Plan.
<br>
<br>
<center><table class="docTable" width=98%>
  <colgroup span="10" class="columns"></colgroup>
  <tr><th>Guideline</th><th>Description</th><th>Category</th><th>Revised Category</th></tr>
  <tr>                                           
    <td width=5%>Dir-1.1</td>
    <td>Any implementation-defined behaviour on which the output of the program depends shall be documented and understood</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Dir-2.1</td>
    <td>All source files shall compile without any compilation errors</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10% class="docCellBlue">Disapplied</td>
  </tr>
  <tr>                                           
    <td width=5%>Dir-3.1</td>
    <td>All code shall be traceable to documented requirements</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10% class="docCellBlue">Disapplied</td>
  </tr>
  <tr>                                           
    <td width=5%>Dir-4.1</td>
    <td>Run-time failures shall be minimized</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Dir-4.10</td>
    <td>Precautions shall be taken in order to prevent the contents of a header file being included more then once</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Dir-4.11</td>
    <td>The validity of values passed to library functions shall be checked</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10% class="docCellBlue">Disapplied</td>
  </tr>
  <tr>                                           
    <td width=5%>Dir-4.12</td>
    <td>Dynamic memory allocation shall not be used</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10% class="docCellBlue">Disapplied</td>
  </tr>
  <tr>                                           
    <td width=5%>Dir-4.13</td>
    <td>Functions which are designed to provide operations on a resource should be called in an appropriate sequence</td>
    <td align=center width=10%>Advisory</td>
    <td align=center width=10% class="docCellBlue">Disapplied</td>
  </tr>
  <tr>                                           
    <td width=5%>Dir-4.14</td>
    <td>The validity of values received from external sources shall be checked</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Dir-4.2</td>
    <td>All usage of assembly language should be documented</td>
    <td align=center width=10%>Advisory</td>
    <td align=center width=10%>Advisory</td>
  </tr>
  <tr>                                           
    <td width=5%>Dir-4.3</td>
    <td>Assembly language shall be encapsulated and isolated</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Dir-4.4</td>
    <td>Sections of code should not be "commented out"</td>
    <td align=center width=10%>Advisory</td>
    <td align=center width=10% class="docCellBlue">Disapplied</td>
  </tr>
  <tr>                                           
    <td width=5%>Dir-4.5</td>
    <td>Identifiers in the same name space with overlapping visibility should be typographically unambiguous</td>
    <td align=center width=10%>Advisory</td>
    <td align=center width=10% class="docCellBlue">Disapplied</td>
  </tr>
  <tr>                                           
    <td width=5%>Dir-4.6</td>
    <td>typedefs that indicate size and signedness should be used in place of the basic numerical types</td>
    <td align=center width=10%>Advisory</td>
    <td align=center width=10%>Advisory</td>
  </tr>
  <tr>                                           
    <td width=5%>Dir-4.7</td>
    <td>If a function returns error information, then that error information shall be tested</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10% class="docCellBlue">Disapplied</td>
  </tr>
  <tr>                                           
    <td width=5%>Dir-4.8</td>
    <td>If a pointer to a structure or union is never dereferenced within a translation unit, then the implementation of the object should be hidden</td>
    <td align=center width=10%>Advisory</td>
    <td align=center width=10% class="docCellBlue">Disapplied</td>
  </tr>
  <tr>                                           
    <td width=5%>Dir-4.9</td>
    <td>A function should be used in preference to a function-like macro where they are interchangeable</td>
    <td align=center width=10%>Advisory</td>
    <td align=center width=10% class="docCellBlue">Disapplied</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-1.1</td>
    <td>The program shall contain no violations of the standard C syntax and constraints, and shall not exceed the implementation's translation limits</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-1.2</td>
    <td>Language extensions should not be used</td>
    <td align=center width=10%>Advisory</td>
    <td align=center width=10%>Advisory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-1.3</td>
    <td>There shall be no occurrence of undefined or critical unspecified behaviour</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-10.1</td>
    <td>Operands shall not be of an inappropriate essential type.</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-10.2</td>
    <td>Expressions of essentially character type shall not be used inappropriately in addition and subtraction operations</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-10.3</td>
    <td>The value of an expression shall not be assigned to an object with a narrower essential type or of a different essential type category.</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-10.4</td>
    <td>Both operands of an operator in which the usual arithmetic conversions are performed shall have the same essential type category</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-10.5</td>
    <td>The value of an expression should not be cast to an inappropriate essential type</td>
    <td align=center width=10%>Advisory</td>
    <td align=center width=10%>Advisory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-10.6</td>
    <td>The value of a composite expression shall not be assigned to an object with wider essential type</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-10.7</td>
    <td>If a composite expression is used as one operand of an operator in which the usual arithmetic conversions are performed then the other operand shall not have wider essential type</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-10.8</td>
    <td>The value of a composite expression shall not be cast to a different essential type category or a wider essential type</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-11.1</td>
    <td>Conversions shall not be performed between a pointer to a function and any other type</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-11.2</td>
    <td>Conversions shall not be performed between a pointer to an incomplete type and any other type</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-11.3</td>
    <td>A cast shall not be performed between a pointer to object type and a pointer to a different object type</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-11.4</td>
    <td>A conversion should not be performed between a pointer to object and an integer type</td>
    <td align=center width=10%>Advisory</td>
    <td align=center width=10%>Advisory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-11.5</td>
    <td>A conversion should not be performed from pointer to void into pointer to object</td>
    <td align=center width=10%>Advisory</td>
    <td align=center width=10%>Advisory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-11.6</td>
    <td>A cast shall not be performed between pointer to void and an arithmetic type</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-11.7</td>
    <td>A cast shall not be performed between pointer to object and a non-integer arithmetic type</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-11.8</td>
    <td>A cast shall not remove any const or volatile qualification from the type pointed to by a pointer</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-11.9</td>
    <td>The macro NULL shall be the only permitted form of integer null pointer constant</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10% class="docCellBlue">Disapplied</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-12.1</td>
    <td>The precedence of operators within expressions should be made explicit</td>
    <td align=center width=10%>Advisory</td>
    <td align=center width=10%>Advisory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-12.2</td>
    <td>The right hand operand of a shift operator shall lie in the range zero to one less than the width in bits of the essential type of the left hand operand</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-12.3</td>
    <td>The comma operator should not be used</td>
    <td align=center width=10%>Advisory</td>
    <td align=center width=10%>Advisory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-12.4</td>
    <td>Evaluation of constant expressions should not lead to unsigned integer wrap-around</td>
    <td align=center width=10%>Advisory</td>
    <td align=center width=10%>Advisory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-12.5</td>
    <td>The sizeof operator shall not have an operand which is a function parameter declared as 'array of type'</td>
    <td align=center width=10%>Mandatory</td>
    <td align=center width=10%>Mandatory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-13.1</td>
    <td>Initializer lists shall not contain persistent side-effects</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-13.2</td>
    <td>The value of an expression and its persistent side-effects shall be the same under all permitted evaluation orders</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-13.3</td>
    <td>A full expression containing an increment (++) or decrement (--) operator should have no other potential side effects other than that caused by the increment or decrement operator</td>
    <td align=center width=10%>Advisory</td>
    <td align=center width=10% class="docCellBlue">Disapplied</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-13.4</td>
    <td>The result of an assignment operator should not be used</td>
    <td align=center width=10%>Advisory</td>
    <td align=center width=10%>Advisory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-13.5</td>
    <td>The right hand operand of a logical && or || operator shall not contain persistent side effects</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-13.6</td>
    <td>The operand of the sizeof operator shall not contain any expression which has potential side-effects</td>
    <td align=center width=10%>Mandatory</td>
    <td align=center width=10%>Mandatory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-14.1</td>
    <td>A loop counter shall not have essentially floating type</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-14.2</td>
    <td>A for loop shall be well-formed</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-14.3</td>
    <td>Controlling expressions shall not be invariant</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-14.4</td>
    <td>The controlling expression of an if-statement and the controlling expression of an iteration-statement shall have essentially Boolean type</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-15.1</td>
    <td>The goto statement should not be used</td>
    <td align=center width=10%>Advisory</td>
    <td align=center width=10%>Advisory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-15.2</td>
    <td>The goto statement shall jump to a label declared later in the same function</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-15.3</td>
    <td>Any label referenced by a goto statement shall be declared in the same block, or in any block enclosing the goto statement</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-15.4</td>
    <td>There should be no more than one break or goto statement used to terminate any iteration statement</td>
    <td align=center width=10%>Advisory</td>
    <td align=center width=10%>Advisory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-15.5</td>
    <td>A function should have a single point of exit at the end</td>
    <td align=center width=10%>Advisory</td>
    <td align=center width=10% class="docCellBlue">Disapplied</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-15.6</td>
    <td>The body of an iteration-statement or a selection-statement shall be a compound-statement</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-15.7</td>
    <td>All if ... else if constructs shall be terminated with an else statement</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-16.1</td>
    <td>All switch statements shall be well-formed</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-16.2</td>
    <td>A switch label shall only be used when the most closely-enclosing compound statement is the body of a switch statement</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-16.3</td>
    <td>An unconditional break statement shall terminate every switch-clause</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-16.4</td>
    <td>Every switch statement shall have a default label</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-16.5</td>
    <td>A default label shall appear as either the first or the last switch label of a switch statement</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-16.6</td>
    <td>Every switch statement shall have at least two switch-clauses</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-16.7</td>
    <td>A switch-expression shall not have essentially Boolean type</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-17.1</td>
    <td>The features of <stdarg.h> shall not be used</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-17.2</td>
    <td>Functions shall not call themselves, either directly or indirectly</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-17.3</td>
    <td>A function shall not be declared implicitly</td>
    <td align=center width=10%>Mandatory</td>
    <td align=center width=10%>Mandatory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-17.4</td>
    <td>All exit paths from a function with non-void return type shall have an explicit return statement with an expression</td>
    <td align=center width=10%>Mandatory</td>
    <td align=center width=10%>Mandatory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-17.5</td>
    <td>The function argument corresponding to a parameter declared to have an array type shall have an appropriate number of elements</td>
    <td align=center width=10%>Advisory</td>
    <td align=center width=10%>Advisory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-17.6</td>
    <td>The declaration of an array parameter shall not contain the static keyword between the [ ]</td>
    <td align=center width=10%>Mandatory</td>
    <td align=center width=10%>Mandatory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-17.7</td>
    <td>The value returned by a function having non-void return type shall be used</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10% class="docCellBlue">Disapplied</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-17.8</td>
    <td>A function parameter should not be modified</td>
    <td align=center width=10%>Advisory</td>
    <td align=center width=10%>Advisory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-18.1</td>
    <td>A pointer resulting from arithmetic on a pointer operand shall address an element of the same array as that pointer operand</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-18.2</td>
    <td>Subtraction between pointers shall only be applied to pointers that address elements of the same array</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-18.3</td>
    <td>The relational operators >, >=, < and <= shall not be applied to objects of pointer type except where they point into the same object</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-18.4</td>
    <td>The +, -, += and -= operators should not be applied to an expression of pointer type</td>
    <td align=center width=10%>Advisory</td>
    <td align=center width=10%>Advisory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-18.5</td>
    <td>Declarations should contain no more than two levels of pointer nesting</td>
    <td align=center width=10%>Advisory</td>
    <td align=center width=10%>Advisory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-18.6</td>
    <td>The address of an object with automatic storage shall not be copied to another object that persists after the first object has ceased to exist</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-18.7</td>
    <td>Flexible array members shall not be declared</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-18.8</td>
    <td>Variable-length array types shall not be used</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-19.1</td>
    <td>An object shall not be assigned or copied to an overlapping object</td>
    <td align=center width=10%>Mandatory</td>
    <td align=center width=10%>Mandatory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-19.2</td>
    <td>The union keyword should not be used</td>
    <td align=center width=10%>Advisory</td>
    <td align=center width=10%>Advisory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-2.1</td>
    <td>A project shall not contain unreachable code</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-2.2</td>
    <td>There shall be no dead code</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-2.3</td>
    <td>A project should not contain unused type declarations</td>
    <td align=center width=10%>Advisory</td>
    <td align=center width=10% class="docCellBlue">Disapplied</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-2.4</td>
    <td>A project should not contain unused tag declarations</td>
    <td align=center width=10%>Advisory</td>
    <td align=center width=10%>Advisory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-2.5</td>
    <td>A project should not contain unused macro declarations</td>
    <td align=center width=10%>Advisory</td>
    <td align=center width=10% class="docCellBlue">Disapplied</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-2.6</td>
    <td>A function should not contain unused label declarations</td>
    <td align=center width=10%>Advisory</td>
    <td align=center width=10%>Advisory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-2.7</td>
    <td>There should be no unused parameters in functions</td>
    <td align=center width=10%>Advisory</td>
    <td align=center width=10%>Advisory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-20.1</td>
    <td>#include directives should only be preceded by preprocessor directives or comments</td>
    <td align=center width=10%>Advisory</td>
    <td align=center width=10%>Advisory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-20.10</td>
    <td>The # and ## preprocessor operators should not be used</td>
    <td align=center width=10%>Advisory</td>
    <td align=center width=10%>Advisory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-20.11</td>
    <td>A macro parameter immediately following a # operator shall not immediately be followed by a ## operator</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-20.12</td>
    <td>A macro parameter used as an operand to the # or ## operators, which is itself subject to further macro replacement, shall only be used as an operand to these operators</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-20.13</td>
    <td>A line whose first token is # shall be a valid preprocessing directive</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-20.14</td>
    <td>All #else, #elif and #endif preprocessor directives shall reside in the same file as the #if, #ifdef or #ifndef directive to which they are related</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-20.2</td>
    <td>The ', " or \ characters and the /* or // character sequences shall not occur in a header file name</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-20.3</td>
    <td>The #include directive shall be followed by either a <filename> or "filename" sequence</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-20.4</td>
    <td>A macro shall not be defined with the same name as a keyword</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-20.5</td>
    <td>#undef should not be used</td>
    <td align=center width=10%>Advisory</td>
    <td align=center width=10%>Advisory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-20.6</td>
    <td>Tokens that look like a preprocessing directive shall not occur within a macro argument</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-20.7</td>
    <td>Expressions resulting from the expansion of macro parameters shall be enclosed in parentheses</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-20.8</td>
    <td>The controlling expression of a #if or #elif preprocessing directive shall evaluate to 0 or 1</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-20.9</td>
    <td>All identifiers used in the controlling expression of #if or #elif preprocessing directives shall be #define'd before evaluation</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-21.1</td>
    <td>#define and #undef shall not be used on a reserved identifier or reserved macro name</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-21.10</td>
    <td>The Standard Library time and date functions shall not be used</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-21.11</td>
    <td>The standard header file <tgmath.h> shall not be used</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-21.12</td>
    <td>The exception handling features of <fenv.h> should not be used</td>
    <td align=center width=10%>Advisory</td>
    <td align=center width=10%>Advisory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-21.13</td>
    <td>Any value passed to a function in <ctype.h> shall be representable as an unsigned char or be the value EOF</td>
    <td align=center width=10%>Mandatory</td>
    <td align=center width=10%>Mandatory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-21.14</td>
    <td>The Standard Library function memcmp shall not be used to compare null terminated strings</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-21.15</td>
    <td>The pointer arguments to the Standard Library functions memcpy, memmove and memcmp shall be pointers to qualified or unqualified versions of compatible types</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-21.16</td>
    <td>The pointer arguments to the Standard Library function memcpy shall point to either a pointer type, an essentially signed type, an essentially unsigned type, an essentially Boolean type or an essentially enum type</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-21.17</td>
    <td>Use of the string handling functions from <string.h> shall not result in accesses beyond the bounds of the objects referenced by their pointer parameters</td>
    <td align=center width=10%>Mandatory</td>
    <td align=center width=10%>Mandatory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-21.18</td>
    <td>The size_t argument passed to any function in <string.h> shall have an appropriate value</td>
    <td align=center width=10%>Mandatory</td>
    <td align=center width=10%>Mandatory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-21.19</td>
    <td>The pointers returned by the Standard Library functions lovaleconv, getenv, setlocale or strerror shall only be used as if they have pointer to const-qualified type</td>
    <td align=center width=10%>Mandatory</td>
    <td align=center width=10%>Mandatory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-21.2</td>
    <td>A reserved identifier or macro name shall not be declared</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-21.20</td>
    <td>The pointer returned by the Standard Library functions asctime, ctime, gmtime, localtime, localeconv, getenv, setlocale, or strerror shall not be used following a subsequent call to the same function</td>
    <td align=center width=10%>Mandatory</td>
    <td align=center width=10%>Mandatory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-21.3</td>
    <td>The memory allocation and deallocation functions of <stdlib.h> shall not be used</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-21.4</td>
    <td>The standard header file <setjmp.h> shall not be used</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-21.5</td>
    <td>The standard header file <signal.h> shall not be used</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-21.6</td>
    <td>The Standard Library input/output functions shall not be used</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-21.7</td>
    <td>The atof, atoi, atol and atoll functions of <stdlib.h> shall not be used</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-21.8</td>
    <td>The library functions abort, exit and system of <stdlib.h> shall not be used</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-21.9</td>
    <td>The library functions bsearch and qsort of <stdlib.h> shall not be used</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-22.1</td>
    <td>All resources obtained dynamically by means of Standard Library functions shall be explicitly released</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-22.10</td>
    <td>The value of errno shall only be tested when the last function to be called was an errno-setting-function</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-22.2</td>
    <td>A block of memory shall only be freed if it was allocated by means of a Standard Library function</td>
    <td align=center width=10%>Mandatory</td>
    <td align=center width=10%>Mandatory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-22.3</td>
    <td>The same file shall not be open for read and write access at the same time on different streams</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-22.4</td>
    <td>There shall be no attempt to write to a stream which has been opened as read-only</td>
    <td align=center width=10%>Mandatory</td>
    <td align=center width=10%>Mandatory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-22.5</td>
    <td>A pointer to a FILE object shall not be dereferenced</td>
    <td align=center width=10%>Mandatory</td>
    <td align=center width=10%>Mandatory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-22.6</td>
    <td>The value of a pointer to a FILE shall not be used after the associated stream has been closed</td>
    <td align=center width=10%>Mandatory</td>
    <td align=center width=10%>Mandatory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-22.7</td>
    <td>The macro EOF shall on ly be compared with the unmodified return value from any Standard Library function capable of returning EOF</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-22.8</td>
    <td>The value of errno shall be set to zero prior to a call to an errno-setting-function</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-22.9</td>
    <td>The value of errno shall be tested against zero after calling an errno-setting-function</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-3.1</td>
    <td>The character sequences /* and // shall not be used within a comment.</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-3.2</td>
    <td>Line-splicing shall not be used in // comments.</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-4.1</td>
    <td>Octal and hexadecimal escape sequences shall be terminated</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-4.2</td>
    <td>Trigraphs should not be used</td>
    <td align=center width=10%>Advisory</td>
    <td align=center width=10%>Advisory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-5.1</td>
    <td>External identifiers shall be distinct</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-5.2</td>
    <td>Identifiers declared in the same scope and name space shall be distinct</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-5.3</td>
    <td>An identifier declared in an inner scope shall not hide an identifier declared in an outer scope</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-5.4</td>
    <td>Macro identifiers shall be distinct</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-5.5</td>
    <td>Identifiers shall be distinct from macro names</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-5.6</td>
    <td>A typedef name shall be a unique identifier</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-5.7</td>
    <td>A tag name shall be a unique identifier</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-5.8</td>
    <td>Identifiers that define objects or functions with external linkage shall be unique</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-5.9</td>
    <td>Identifiers that define objects or functions with internal linkage should be unique</td>
    <td align=center width=10%>Advisory</td>
    <td align=center width=10%>Advisory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-6.1</td>
    <td>Bit-fields shall only be declared with an appropriate type</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-6.2</td>
    <td>Single-bit named bit fields shall not be of a signed type</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-7.1</td>
    <td>Octal constants shall not be used</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-7.2</td>
    <td>A "u" or "U" suffix shall be applied to all integer constants that are represented in an unsigned type</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-7.3</td>
    <td>The lowercase character "l" shall not be used in a literal suffix</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-7.4</td>
    <td>A string literal shall not be assigned to an object unless the object's type is "pointer to const-qualified char"</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-8.1</td>
    <td>Types shall be explicitly specified</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-8.10</td>
    <td>An inline function shall be declared with the static storage class</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-8.11</td>
    <td>When an array with external linkage is declared, its size should be explicitly specified</td>
    <td align=center width=10%>Advisory</td>
    <td align=center width=10%>Advisory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-8.12</td>
    <td>Within an enumerator list, the value of an implicitly-specified enumeration constant shall be unique</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-8.13</td>
    <td>A pointer should point to a const-qualified type whenever possible</td>
    <td align=center width=10%>Advisory</td>
    <td align=center width=10%>Advisory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-8.14</td>
    <td>The restrict type qualifier shall not be used</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-8.2</td>
    <td>Function types shall be in prototype form with named parameters</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-8.3</td>
    <td>All declarations of an object or function shall use the same names and type qualifiers</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-8.4</td>
    <td>A compatible declaration shall be visible when an object or function with external linkage is defined</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-8.5</td>
    <td>An external object or function shall be declared once in one and only one file</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-8.6</td>
    <td>An identifier with external linkage shall have exactly one external definition</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-8.7</td>
    <td>Functions and objects should not be defined with external linkage if they are referenced in only one translation unit</td>
    <td align=center width=10%>Advisory</td>
    <td align=center width=10% class="docCellBlue">Disapplied</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-8.8</td>
    <td>The static storage class specifier shall be used in all declarations of objects and functions that have internal linkage</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-8.9</td>
    <td>An object should be defined at block scope if its identifier only appears in a single function</td>
    <td align=center width=10%>Advisory</td>
    <td align=center width=10%>Advisory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-9.1</td>
    <td>The value of an object with automatic storage duration shall not be read before it has been set</td>
    <td align=center width=10%>Mandatory</td>
    <td align=center width=10%>Mandatory</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-9.2</td>
    <td>The initializer for an aggregate or union shall be enclosed in braces</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-9.3</td>
    <td>Arrays shall not be partially initialized</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-9.4</td>
    <td>An element of an object shall not be initialized more than once</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
  <tr>                                           
    <td width=5%>Rule-9.5</td>
    <td>Where designated initializers are used to initialize an array object the size of the array shall be specified explicitly</td>
    <td align=center width=10%>Required</td>
    <td align=center width=10%>Required</td>
  </tr>
</table></center>
</div>
<div class="GCS">
<div class="sec"><h2><a name="GCS">GCS - Guideline Compliance Summary</a></h2></div>
This section targets to provide an overview of Guidelines Compliance Summary.
<br>
<br>
<center><table class="docTable" width=98%>
  <colgroup span="10" class="columns"></colgroup>
  <tr><th>Guideline</th><th>Category</th><th>Description</th><th>Compliance</th></tr>
  <tr>
    <td width=2%>Dir-1.1</td>
    <td width=2%>Required</td>
    <td width=50%>Any implementation-defined behaviour on which the output of the program depends shall be documented and understood</td>
    <td class="docCellGreen">Compliant<br><br>with deviations:<br>
<center><table width=95%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0292</td>
    <td width=95%> [I] Source file '%s' has comments containing one of the characters '$', '@' or '`'.</td>
  </tr>
  <tr>
    <td width=5%>0315</td>
    <td width=95%> [I] Implicit conversion from a pointer to object type to a pointer to void.</td>
  </tr>
  <tr>
    <td width=5%>0380</td>
    <td width=95%> [L] Number of macro definitions exceeds 4095 - program does not conform strictly to ISO:C99.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>
    <td width=2%>Dir-2.1</td>
    <td width=2%>Required</td>
    <td width=50%>All source files shall compile without any compilation errors</td>
    <td class="docCellOrange">Disapplied</td>
  </tr>
  <tr>
    <td width=2%>Dir-3.1</td>
    <td width=2%>Required</td>
    <td width=50%>All code shall be traceable to documented requirements</td>
    <td class="docCellOrange">Disapplied</td>
  </tr>
  <tr>
    <td width=2%>Dir-4.1</td>
    <td width=2%>Required</td>
    <td width=50%>Run-time failures shall be minimized</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Dir-4.10</td>
    <td width=2%>Required</td>
    <td width=50%>Precautions shall be taken in order to prevent the contents of a header file being included more then once</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Dir-4.11</td>
    <td width=2%>Required</td>
    <td width=50%>The validity of values passed to library functions shall be checked</td>
    <td class="docCellOrange">Disapplied</td>
  </tr>
  <tr>
    <td width=2%>Dir-4.12</td>
    <td width=2%>Required</td>
    <td width=50%>Dynamic memory allocation shall not be used</td>
    <td class="docCellOrange">Disapplied</td>
  </tr>
  <tr>
    <td width=2%>Dir-4.13</td>
    <td width=2%>Advisory</td>
    <td width=50%>Functions which are designed to provide operations on a resource should be called in an appropriate sequence</td>
    <td class="docCellOrange">Disapplied</td>
  </tr>
  <tr>
    <td width=2%>Dir-4.14</td>
    <td width=2%>Required</td>
    <td width=50%>The validity of values received from external sources shall be checked</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Dir-4.2</td>
    <td width=2%>Advisory</td>
    <td width=50%>All usage of assembly language should be documented</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Dir-4.3</td>
    <td width=2%>Required</td>
    <td width=50%>Assembly language shall be encapsulated and isolated</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Dir-4.4</td>
    <td width=2%>Advisory</td>
    <td width=50%>Sections of code should not be "commented out"</td>
    <td class="docCellOrange">Disapplied</td>
  </tr>
  <tr>
    <td width=2%>Dir-4.5</td>
    <td width=2%>Advisory</td>
    <td width=50%>Identifiers in the same name space with overlapping visibility should be typographically unambiguous</td>
    <td class="docCellOrange">Disapplied</td>
  </tr>
  <tr>
    <td width=2%>Dir-4.6</td>
    <td width=2%>Advisory</td>
    <td width=50%>typedefs that indicate size and signedness should be used in place of the basic numerical types</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Dir-4.7</td>
    <td width=2%>Required</td>
    <td width=50%>If a function returns error information, then that error information shall be tested</td>
    <td class="docCellOrange">Disapplied</td>
  </tr>
  <tr>
    <td width=2%>Dir-4.8</td>
    <td width=2%>Advisory</td>
    <td width=50%>If a pointer to a structure or union is never dereferenced within a translation unit, then the implementation of the object should be hidden</td>
    <td class="docCellOrange">Disapplied</td>
  </tr>
  <tr>
    <td width=2%>Dir-4.9</td>
    <td width=2%>Advisory</td>
    <td width=50%>A function should be used in preference to a function-like macro where they are interchangeable</td>
    <td class="docCellOrange">Disapplied</td>
  </tr>
  <tr>
    <td width=2%>Rule-1.1</td>
    <td width=2%>Required</td>
    <td width=50%>The program shall contain no violations of the standard C syntax and constraints, and shall not exceed the implementation's translation limits</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-1.2</td>
    <td width=2%>Advisory</td>
    <td width=50%>Language extensions should not be used</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-1.3</td>
    <td width=2%>Required</td>
    <td width=50%>There shall be no occurrence of undefined or critical unspecified behaviour</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-10.1</td>
    <td width=2%>Required</td>
    <td width=50%>Operands shall not be of an inappropriate essential type.</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-10.2</td>
    <td width=2%>Required</td>
    <td width=50%>Expressions of essentially character type shall not be used inappropriately in addition and subtraction operations</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-10.3</td>
    <td width=2%>Required</td>
    <td width=50%>The value of an expression shall not be assigned to an object with a narrower essential type or of a different essential type category.</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-10.4</td>
    <td width=2%>Required</td>
    <td width=50%>Both operands of an operator in which the usual arithmetic conversions are performed shall have the same essential type category</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-10.5</td>
    <td width=2%>Advisory</td>
    <td width=50%>The value of an expression should not be cast to an inappropriate essential type</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-10.6</td>
    <td width=2%>Required</td>
    <td width=50%>The value of a composite expression shall not be assigned to an object with wider essential type</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-10.7</td>
    <td width=2%>Required</td>
    <td width=50%>If a composite expression is used as one operand of an operator in which the usual arithmetic conversions are performed then the other operand shall not have wider essential type</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-10.8</td>
    <td width=2%>Required</td>
    <td width=50%>The value of a composite expression shall not be cast to a different essential type category or a wider essential type</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-11.1</td>
    <td width=2%>Required</td>
    <td width=50%>Conversions shall not be performed between a pointer to a function and any other type</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-11.2</td>
    <td width=2%>Required</td>
    <td width=50%>Conversions shall not be performed between a pointer to an incomplete type and any other type</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-11.3</td>
    <td width=2%>Required</td>
    <td width=50%>A cast shall not be performed between a pointer to object type and a pointer to a different object type</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-11.4</td>
    <td width=2%>Advisory</td>
    <td width=50%>A conversion should not be performed between a pointer to object and an integer type</td>
    <td class="docCellGreen">Compliant<br><br>with deviations:<br>
<center><table width=95%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0306</td>
    <td width=95%> [I] Cast between a pointer to object and an integral type.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>
    <td width=2%>Rule-11.5</td>
    <td width=2%>Advisory</td>
    <td width=50%>A conversion should not be performed from pointer to void into pointer to object</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-11.6</td>
    <td width=2%>Required</td>
    <td width=50%>A cast shall not be performed between pointer to void and an arithmetic type</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-11.7</td>
    <td width=2%>Required</td>
    <td width=50%>A cast shall not be performed between pointer to object and a non-integer arithmetic type</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-11.8</td>
    <td width=2%>Required</td>
    <td width=50%>A cast shall not remove any const or volatile qualification from the type pointed to by a pointer</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-11.9</td>
    <td width=2%>Required</td>
    <td width=50%>The macro NULL shall be the only permitted form of integer null pointer constant</td>
    <td class="docCellOrange">Disapplied</td>
  </tr>
  <tr>
    <td width=2%>Rule-12.1</td>
    <td width=2%>Advisory</td>
    <td width=50%>The precedence of operators within expressions should be made explicit</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-12.2</td>
    <td width=2%>Required</td>
    <td width=50%>The right hand operand of a shift operator shall lie in the range zero to one less than the width in bits of the essential type of the left hand operand</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-12.3</td>
    <td width=2%>Advisory</td>
    <td width=50%>The comma operator should not be used</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-12.4</td>
    <td width=2%>Advisory</td>
    <td width=50%>Evaluation of constant expressions should not lead to unsigned integer wrap-around</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-12.5</td>
    <td width=2%>Mandatory</td>
    <td width=50%>The sizeof operator shall not have an operand which is a function parameter declared as 'array of type'</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-13.1</td>
    <td width=2%>Required</td>
    <td width=50%>Initializer lists shall not contain persistent side-effects</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-13.2</td>
    <td width=2%>Required</td>
    <td width=50%>The value of an expression and its persistent side-effects shall be the same under all permitted evaluation orders</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-13.3</td>
    <td width=2%>Advisory</td>
    <td width=50%>A full expression containing an increment (++) or decrement (--) operator should have no other potential side effects other than that caused by the increment or decrement operator</td>
    <td class="docCellOrange">Disapplied</td>
  </tr>
  <tr>
    <td width=2%>Rule-13.4</td>
    <td width=2%>Advisory</td>
    <td width=50%>The result of an assignment operator should not be used</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-13.5</td>
    <td width=2%>Required</td>
    <td width=50%>The right hand operand of a logical && or || operator shall not contain persistent side effects</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-13.6</td>
    <td width=2%>Mandatory</td>
    <td width=50%>The operand of the sizeof operator shall not contain any expression which has potential side-effects</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-14.1</td>
    <td width=2%>Required</td>
    <td width=50%>A loop counter shall not have essentially floating type</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-14.2</td>
    <td width=2%>Required</td>
    <td width=50%>A for loop shall be well-formed</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-14.3</td>
    <td width=2%>Required</td>
    <td width=50%>Controlling expressions shall not be invariant</td>
    <td class="docCellGreen">Compliant<br><br>with deviations:<br>
<center><table width=95%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>2991</td>
    <td width=95%> The value of this 'if' controlling expression is always 'true'.</td>
  </tr>
  <tr>
    <td width=5%>2992</td>
    <td width=95%> The value of this 'if' controlling expression is always 'false'.</td>
  </tr>
  <tr>
    <td width=5%>2998</td>
    <td width=95%> The first operand of this conditional operator is always 'false'.</td>
  </tr>
  <tr>
    <td width=5%>3493</td>
    <td width=95%> The first operand of this conditional operator is always constant 'true'.</td>
  </tr>
  <tr>
    <td width=5%>3494</td>
    <td width=95%> The first operand of this conditional operator is always constant 'false'.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>
    <td width=2%>Rule-14.4</td>
    <td width=2%>Required</td>
    <td width=50%>The controlling expression of an if-statement and the controlling expression of an iteration-statement shall have essentially Boolean type</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-15.1</td>
    <td width=2%>Advisory</td>
    <td width=50%>The goto statement should not be used</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-15.2</td>
    <td width=2%>Required</td>
    <td width=50%>The goto statement shall jump to a label declared later in the same function</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-15.3</td>
    <td width=2%>Required</td>
    <td width=50%>Any label referenced by a goto statement shall be declared in the same block, or in any block enclosing the goto statement</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-15.4</td>
    <td width=2%>Advisory</td>
    <td width=50%>There should be no more than one break or goto statement used to terminate any iteration statement</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-15.5</td>
    <td width=2%>Advisory</td>
    <td width=50%>A function should have a single point of exit at the end</td>
    <td class="docCellOrange">Disapplied</td>
  </tr>
  <tr>
    <td width=2%>Rule-15.6</td>
    <td width=2%>Required</td>
    <td width=50%>The body of an iteration-statement or a selection-statement shall be a compound-statement</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-15.7</td>
    <td width=2%>Required</td>
    <td width=50%>All if ... else if constructs shall be terminated with an else statement</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-16.1</td>
    <td width=2%>Required</td>
    <td width=50%>All switch statements shall be well-formed</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-16.2</td>
    <td width=2%>Required</td>
    <td width=50%>A switch label shall only be used when the most closely-enclosing compound statement is the body of a switch statement</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-16.3</td>
    <td width=2%>Required</td>
    <td width=50%>An unconditional break statement shall terminate every switch-clause</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-16.4</td>
    <td width=2%>Required</td>
    <td width=50%>Every switch statement shall have a default label</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-16.5</td>
    <td width=2%>Required</td>
    <td width=50%>A default label shall appear as either the first or the last switch label of a switch statement</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-16.6</td>
    <td width=2%>Required</td>
    <td width=50%>Every switch statement shall have at least two switch-clauses</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-16.7</td>
    <td width=2%>Required</td>
    <td width=50%>A switch-expression shall not have essentially Boolean type</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-17.1</td>
    <td width=2%>Required</td>
    <td width=50%>The features of <stdarg.h> shall not be used</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-17.2</td>
    <td width=2%>Required</td>
    <td width=50%>Functions shall not call themselves, either directly or indirectly</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-17.3</td>
    <td width=2%>Mandatory</td>
    <td width=50%>A function shall not be declared implicitly</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-17.4</td>
    <td width=2%>Mandatory</td>
    <td width=50%>All exit paths from a function with non-void return type shall have an explicit return statement with an expression</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-17.5</td>
    <td width=2%>Advisory</td>
    <td width=50%>The function argument corresponding to a parameter declared to have an array type shall have an appropriate number of elements</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-17.6</td>
    <td width=2%>Mandatory</td>
    <td width=50%>The declaration of an array parameter shall not contain the static keyword between the [ ]</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-17.7</td>
    <td width=2%>Required</td>
    <td width=50%>The value returned by a function having non-void return type shall be used</td>
    <td class="docCellOrange">Disapplied</td>
  </tr>
  <tr>
    <td width=2%>Rule-17.8</td>
    <td width=2%>Advisory</td>
    <td width=50%>A function parameter should not be modified</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-18.1</td>
    <td width=2%>Required</td>
    <td width=50%>A pointer resulting from arithmetic on a pointer operand shall address an element of the same array as that pointer operand</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-18.2</td>
    <td width=2%>Required</td>
    <td width=50%>Subtraction between pointers shall only be applied to pointers that address elements of the same array</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-18.3</td>
    <td width=2%>Required</td>
    <td width=50%>The relational operators >, >=, < and <= shall not be applied to objects of pointer type except where they point into the same object</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-18.4</td>
    <td width=2%>Advisory</td>
    <td width=50%>The +, -, += and -= operators should not be applied to an expression of pointer type</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-18.5</td>
    <td width=2%>Advisory</td>
    <td width=50%>Declarations should contain no more than two levels of pointer nesting</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-18.6</td>
    <td width=2%>Required</td>
    <td width=50%>The address of an object with automatic storage shall not be copied to another object that persists after the first object has ceased to exist</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-18.7</td>
    <td width=2%>Required</td>
    <td width=50%>Flexible array members shall not be declared</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-18.8</td>
    <td width=2%>Required</td>
    <td width=50%>Variable-length array types shall not be used</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-19.1</td>
    <td width=2%>Mandatory</td>
    <td width=50%>An object shall not be assigned or copied to an overlapping object</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-19.2</td>
    <td width=2%>Advisory</td>
    <td width=50%>The union keyword should not be used</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-2.1</td>
    <td width=2%>Required</td>
    <td width=50%>A project shall not contain unreachable code</td>
    <td class="docCellGreen">Compliant<br><br>with deviations:<br>
<center><table width=95%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>1503</td>
    <td width=95%> The function '%1s' is defined but is not used within this project.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>
    <td width=2%>Rule-2.2</td>
    <td width=2%>Required</td>
    <td width=50%>There shall be no dead code</td>
    <td class="docCellGreen">Compliant<br><br>with deviations:<br>
<center><table width=95%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>2982</td>
    <td width=95%> This assignment is redundant. The value of this object is never used before being modified.</td>
  </tr>
  <tr>
    <td width=5%>2983</td>
    <td width=95%> This assignment is redundant. The value of this object is never subsequently used.</td>
  </tr>
  <tr>
    <td width=5%>2985</td>
    <td width=95%> This operation is redundant. The value of the result is always that of the left-hand operand.</td>
  </tr>
  <tr>
    <td width=5%>2986</td>
    <td width=95%> This operation is redundant. The value of the result is always that of the right-hand operand.</td>
  </tr>
  <tr>
    <td width=5%>2995</td>
    <td width=95%> The result of this logical operation is always 'true'.</td>
  </tr>
  <tr>
    <td width=5%>2996</td>
    <td width=95%> The result of this logical operation is always 'false'.</td>
  </tr>
  <tr>
    <td width=5%>3112</td>
    <td width=95%> This statement has no side-effect - it can be removed.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>
    <td width=2%>Rule-2.3</td>
    <td width=2%>Advisory</td>
    <td width=50%>A project should not contain unused type declarations</td>
    <td class="docCellOrange">Disapplied</td>
  </tr>
  <tr>
    <td width=2%>Rule-2.4</td>
    <td width=2%>Advisory</td>
    <td width=50%>A project should not contain unused tag declarations</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-2.5</td>
    <td width=2%>Advisory</td>
    <td width=50%>A project should not contain unused macro declarations</td>
    <td class="docCellOrange">Disapplied</td>
  </tr>
  <tr>
    <td width=2%>Rule-2.6</td>
    <td width=2%>Advisory</td>
    <td width=50%>A function should not contain unused label declarations</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-2.7</td>
    <td width=2%>Advisory</td>
    <td width=50%>There should be no unused parameters in functions</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-20.1</td>
    <td width=2%>Advisory</td>
    <td width=50%>#include directives should only be preceded by preprocessor directives or comments</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-20.10</td>
    <td width=2%>Advisory</td>
    <td width=50%>The # and ## preprocessor operators should not be used</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-20.11</td>
    <td width=2%>Required</td>
    <td width=50%>A macro parameter immediately following a # operator shall not immediately be followed by a ## operator</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-20.12</td>
    <td width=2%>Required</td>
    <td width=50%>A macro parameter used as an operand to the # or ## operators, which is itself subject to further macro replacement, shall only be used as an operand to these operators</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-20.13</td>
    <td width=2%>Required</td>
    <td width=50%>A line whose first token is # shall be a valid preprocessing directive</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-20.14</td>
    <td width=2%>Required</td>
    <td width=50%>All #else, #elif and #endif preprocessor directives shall reside in the same file as the #if, #ifdef or #ifndef directive to which they are related</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-20.2</td>
    <td width=2%>Required</td>
    <td width=50%>The ', " or \ characters and the /* or // character sequences shall not occur in a header file name</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-20.3</td>
    <td width=2%>Required</td>
    <td width=50%>The #include directive shall be followed by either a <filename> or "filename" sequence</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-20.4</td>
    <td width=2%>Required</td>
    <td width=50%>A macro shall not be defined with the same name as a keyword</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-20.5</td>
    <td width=2%>Advisory</td>
    <td width=50%>#undef should not be used</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-20.6</td>
    <td width=2%>Required</td>
    <td width=50%>Tokens that look like a preprocessing directive shall not occur within a macro argument</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-20.7</td>
    <td width=2%>Required</td>
    <td width=50%>Expressions resulting from the expansion of macro parameters shall be enclosed in parentheses</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-20.8</td>
    <td width=2%>Required</td>
    <td width=50%>The controlling expression of a #if or #elif preprocessing directive shall evaluate to 0 or 1</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-20.9</td>
    <td width=2%>Required</td>
    <td width=50%>All identifiers used in the controlling expression of #if or #elif preprocessing directives shall be #define'd before evaluation</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-21.1</td>
    <td width=2%>Required</td>
    <td width=50%>#define and #undef shall not be used on a reserved identifier or reserved macro name</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-21.10</td>
    <td width=2%>Required</td>
    <td width=50%>The Standard Library time and date functions shall not be used</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-21.11</td>
    <td width=2%>Required</td>
    <td width=50%>The standard header file <tgmath.h> shall not be used</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-21.12</td>
    <td width=2%>Advisory</td>
    <td width=50%>The exception handling features of <fenv.h> should not be used</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-21.13</td>
    <td width=2%>Mandatory</td>
    <td width=50%>Any value passed to a function in <ctype.h> shall be representable as an unsigned char or be the value EOF</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-21.14</td>
    <td width=2%>Required</td>
    <td width=50%>The Standard Library function memcmp shall not be used to compare null terminated strings</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-21.15</td>
    <td width=2%>Required</td>
    <td width=50%>The pointer arguments to the Standard Library functions memcpy, memmove and memcmp shall be pointers to qualified or unqualified versions of compatible types</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-21.16</td>
    <td width=2%>Required</td>
    <td width=50%>The pointer arguments to the Standard Library function memcpy shall point to either a pointer type, an essentially signed type, an essentially unsigned type, an essentially Boolean type or an essentially enum type</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-21.17</td>
    <td width=2%>Mandatory</td>
    <td width=50%>Use of the string handling functions from <string.h> shall not result in accesses beyond the bounds of the objects referenced by their pointer parameters</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-21.18</td>
    <td width=2%>Mandatory</td>
    <td width=50%>The size_t argument passed to any function in <string.h> shall have an appropriate value</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-21.19</td>
    <td width=2%>Mandatory</td>
    <td width=50%>The pointers returned by the Standard Library functions lovaleconv, getenv, setlocale or strerror shall only be used as if they have pointer to const-qualified type</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-21.2</td>
    <td width=2%>Required</td>
    <td width=50%>A reserved identifier or macro name shall not be declared</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-21.20</td>
    <td width=2%>Mandatory</td>
    <td width=50%>The pointer returned by the Standard Library functions asctime, ctime, gmtime, localtime, localeconv, getenv, setlocale, or strerror shall not be used following a subsequent call to the same function</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-21.3</td>
    <td width=2%>Required</td>
    <td width=50%>The memory allocation and deallocation functions of <stdlib.h> shall not be used</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-21.4</td>
    <td width=2%>Required</td>
    <td width=50%>The standard header file <setjmp.h> shall not be used</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-21.5</td>
    <td width=2%>Required</td>
    <td width=50%>The standard header file <signal.h> shall not be used</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-21.6</td>
    <td width=2%>Required</td>
    <td width=50%>The Standard Library input/output functions shall not be used</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-21.7</td>
    <td width=2%>Required</td>
    <td width=50%>The atof, atoi, atol and atoll functions of <stdlib.h> shall not be used</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-21.8</td>
    <td width=2%>Required</td>
    <td width=50%>The library functions abort, exit and system of <stdlib.h> shall not be used</td>
    <td class="docCellGreen">Compliant<br><br>with deviations:<br>
<center><table width=95%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>5128</td>
    <td width=95%> Use of function: getenv.</td>
  </tr>
</table></center>
</td>
  </tr>
  <tr>
    <td width=2%>Rule-21.9</td>
    <td width=2%>Required</td>
    <td width=50%>The library functions bsearch and qsort of <stdlib.h> shall not be used</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-22.1</td>
    <td width=2%>Required</td>
    <td width=50%>All resources obtained dynamically by means of Standard Library functions shall be explicitly released</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-22.10</td>
    <td width=2%>Required</td>
    <td width=50%>The value of errno shall only be tested when the last function to be called was an errno-setting-function</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-22.2</td>
    <td width=2%>Mandatory</td>
    <td width=50%>A block of memory shall only be freed if it was allocated by means of a Standard Library function</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-22.3</td>
    <td width=2%>Required</td>
    <td width=50%>The same file shall not be open for read and write access at the same time on different streams</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-22.4</td>
    <td width=2%>Mandatory</td>
    <td width=50%>There shall be no attempt to write to a stream which has been opened as read-only</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-22.5</td>
    <td width=2%>Mandatory</td>
    <td width=50%>A pointer to a FILE object shall not be dereferenced</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-22.6</td>
    <td width=2%>Mandatory</td>
    <td width=50%>The value of a pointer to a FILE shall not be used after the associated stream has been closed</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-22.7</td>
    <td width=2%>Required</td>
    <td width=50%>The macro EOF shall on ly be compared with the unmodified return value from any Standard Library function capable of returning EOF</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-22.8</td>
    <td width=2%>Required</td>
    <td width=50%>The value of errno shall be set to zero prior to a call to an errno-setting-function</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-22.9</td>
    <td width=2%>Required</td>
    <td width=50%>The value of errno shall be tested against zero after calling an errno-setting-function</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-3.1</td>
    <td width=2%>Required</td>
    <td width=50%>The character sequences /* and // shall not be used within a comment.</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-3.2</td>
    <td width=2%>Required</td>
    <td width=50%>Line-splicing shall not be used in // comments.</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-4.1</td>
    <td width=2%>Required</td>
    <td width=50%>Octal and hexadecimal escape sequences shall be terminated</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-4.2</td>
    <td width=2%>Advisory</td>
    <td width=50%>Trigraphs should not be used</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-5.1</td>
    <td width=2%>Required</td>
    <td width=50%>External identifiers shall be distinct</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-5.2</td>
    <td width=2%>Required</td>
    <td width=50%>Identifiers declared in the same scope and name space shall be distinct</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-5.3</td>
    <td width=2%>Required</td>
    <td width=50%>An identifier declared in an inner scope shall not hide an identifier declared in an outer scope</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-5.4</td>
    <td width=2%>Required</td>
    <td width=50%>Macro identifiers shall be distinct</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-5.5</td>
    <td width=2%>Required</td>
    <td width=50%>Identifiers shall be distinct from macro names</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-5.6</td>
    <td width=2%>Required</td>
    <td width=50%>A typedef name shall be a unique identifier</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-5.7</td>
    <td width=2%>Required</td>
    <td width=50%>A tag name shall be a unique identifier</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-5.8</td>
    <td width=2%>Required</td>
    <td width=50%>Identifiers that define objects or functions with external linkage shall be unique</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-5.9</td>
    <td width=2%>Advisory</td>
    <td width=50%>Identifiers that define objects or functions with internal linkage should be unique</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-6.1</td>
    <td width=2%>Required</td>
    <td width=50%>Bit-fields shall only be declared with an appropriate type</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-6.2</td>
    <td width=2%>Required</td>
    <td width=50%>Single-bit named bit fields shall not be of a signed type</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-7.1</td>
    <td width=2%>Required</td>
    <td width=50%>Octal constants shall not be used</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-7.2</td>
    <td width=2%>Required</td>
    <td width=50%>A "u" or "U" suffix shall be applied to all integer constants that are represented in an unsigned type</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-7.3</td>
    <td width=2%>Required</td>
    <td width=50%>The lowercase character "l" shall not be used in a literal suffix</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-7.4</td>
    <td width=2%>Required</td>
    <td width=50%>A string literal shall not be assigned to an object unless the object's type is "pointer to const-qualified char"</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-8.1</td>
    <td width=2%>Required</td>
    <td width=50%>Types shall be explicitly specified</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-8.10</td>
    <td width=2%>Required</td>
    <td width=50%>An inline function shall be declared with the static storage class</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-8.11</td>
    <td width=2%>Advisory</td>
    <td width=50%>When an array with external linkage is declared, its size should be explicitly specified</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-8.12</td>
    <td width=2%>Required</td>
    <td width=50%>Within an enumerator list, the value of an implicitly-specified enumeration constant shall be unique</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-8.13</td>
    <td width=2%>Advisory</td>
    <td width=50%>A pointer should point to a const-qualified type whenever possible</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-8.14</td>
    <td width=2%>Required</td>
    <td width=50%>The restrict type qualifier shall not be used</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-8.2</td>
    <td width=2%>Required</td>
    <td width=50%>Function types shall be in prototype form with named parameters</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-8.3</td>
    <td width=2%>Required</td>
    <td width=50%>All declarations of an object or function shall use the same names and type qualifiers</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-8.4</td>
    <td width=2%>Required</td>
    <td width=50%>A compatible declaration shall be visible when an object or function with external linkage is defined</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-8.5</td>
    <td width=2%>Required</td>
    <td width=50%>An external object or function shall be declared once in one and only one file</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-8.6</td>
    <td width=2%>Required</td>
    <td width=50%>An identifier with external linkage shall have exactly one external definition</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-8.7</td>
    <td width=2%>Advisory</td>
    <td width=50%>Functions and objects should not be defined with external linkage if they are referenced in only one translation unit</td>
    <td class="docCellOrange">Disapplied</td>
  </tr>
  <tr>
    <td width=2%>Rule-8.8</td>
    <td width=2%>Required</td>
    <td width=50%>The static storage class specifier shall be used in all declarations of objects and functions that have internal linkage</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-8.9</td>
    <td width=2%>Advisory</td>
    <td width=50%>An object should be defined at block scope if its identifier only appears in a single function</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-9.1</td>
    <td width=2%>Mandatory</td>
    <td width=50%>The value of an object with automatic storage duration shall not be read before it has been set</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-9.2</td>
    <td width=2%>Required</td>
    <td width=50%>The initializer for an aggregate or union shall be enclosed in braces</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-9.3</td>
    <td width=2%>Required</td>
    <td width=50%>Arrays shall not be partially initialized</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-9.4</td>
    <td width=2%>Required</td>
    <td width=50%>An element of an object shall not be initialized more than once</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
  <tr>
    <td width=2%>Rule-9.5</td>
    <td width=2%>Required</td>
    <td width=50%>Where designated initializers are used to initialize an array object the size of the array shall be specified explicitly</td>
    <td class="docCellGreen">Compliant</td>
  </tr>
</table></center>
</div>
<div class="Permits">
<div class="sec"><h2><a name="Permits">Deviation Permits</a></h2></div>
This section targets to provide an overview of Deviation Permits.<br>
All the rules corresponding to the deviation permits are disabled inside PRQA and will not cause any violation or deviation in the Deviation records section below.
<br>
<br>
<center><table class="docTable" width=98%>
  <colgroup span="10" class="columns"></colgroup>
  <tr><th>Guideline</th><th>Category</th><th>Description</th><th>Ratio</th><th>Sub Rules</th><th>Characteristics</th><th>Reason</th></tr>
  <tr>
    <td width=4%>Dir-1.1</td>
    <td width=4%>Required</td>
    <td width=20%>Any implementation-defined behaviour on which the output of the program depends shall be documented and understood</td>
    <td width=2%>3/34</td>
    <td width=30%><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0292</td>
    <td width=95%> [I] Source file '%s' has comments containing one of the characters '$', '@' or '`'.</td>
  </tr>
  <tr>
    <td width=5%>0315</td>
    <td width=95%> [I] Implicit conversion from a pointer to object type to a pointer to void.</td>
  </tr>
  <tr>
    <td width=5%>0380</td>
    <td width=95%> [L] Number of macro definitions exceeds 4095 - program does not conform strictly to ISO:C99.</td>
  </tr>
</table></center>
</td>
    <td width=10%>Maintainability / Analysability</td>
    <td>0292: Invalid characters in comments: Doxygen comments are used.<br>
0315: Library string.h functions (memcpy, etc.)  are used and trigger this implicit conversion.<br>
0380: Already CMSIS and STM32HAL trigger this.<br>
</td>
  <tr>
    <td width=4%>Dir-4.9</td>
    <td width=4%>Advisory</td>
    <td width=20%>A function should be used in preference to a function-like macro where they are interchangeable</td>
    <td width=2%>1/1</td>
    <td width=30%><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3453</td>
    <td width=95%> A function could probably be used instead of this function-like macro.</td>
  </tr>
</table></center>
</td>
    <td width=10%>Performance / Resource utilization</td>
    <td>Suppressed due to code optimization and efficiency.<br></td>
  <tr>
    <td width=4%>Rule-11.4</td>
    <td width=4%>Advisory</td>
    <td width=20%>A conversion should not be performed between a pointer to object and an integer type</td>
    <td width=2%>1/5</td>
    <td width=30%><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>0306</td>
    <td width=95%> [I] Cast between a pointer to object and an integral type.</td>
  </tr>
</table></center>
</td>
    <td width=10%>Maintainability / Modifiability</td>
    <td>Using STM32 HAL already creates many violations. Also needed to do pointer arithmetic, calculating offsets inside a buffer.<br></td>
  <tr>
    <td width=4%>Rule-11.9</td>
    <td width=4%>Required</td>
    <td width=20%>The macro NULL shall be the only permitted form of integer null pointer constant</td>
    <td width=2%>1/2</td>
    <td width=30%><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3004</td>
    <td width=95%> This integral constant expression is being interpreted as a NULL pointer constant.</td>
  </tr>
</table></center>
</td>
    <td width=10%></td>
    <td>Keil stddef.h: "define NULL 0" causes violations. PRQA acknowledged this as a false positive.<br></td>
  <tr>
    <td width=4%>Rule-13.3</td>
    <td width=4%>Advisory</td>
    <td width=20%>A full expression containing an increment (++) or decrement (--) operator should have no other potential side effects other than that caused by the increment or decrement operator</td>
    <td width=2%>1/1</td>
    <td width=30%><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3440</td>
    <td width=95%> Using the value resulting from a ++ or -- operation.</td>
  </tr>
</table></center>
</td>
    <td width=10%>Maintainability / Analysability</td>
    <td>RFAL uses the increment often for building buffers (array[i++] = 42; ...). Splitting this would decrease readability.<br></td>
  <tr>
    <td width=4%>Rule-14.3</td>
    <td width=4%>Required</td>
    <td width=20%>Controlling expressions shall not be invariant</td>
    <td width=2%>6/11</td>
    <td width=30%><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3440</td>
    <td width=95%> Using the value resulting from a ++ or -- operation.</td>
  </tr>
  <tr>
    <td width=5%>2991</td>
    <td width=95%> The value of this 'if' controlling expression is always 'true'.</td>
  </tr>
  <tr>
    <td width=5%>2992</td>
    <td width=95%> The value of this 'if' controlling expression is always 'false'.</td>
  </tr>
  <tr>
    <td width=5%>2998</td>
    <td width=95%> The first operand of this conditional operator is always 'false'.</td>
  </tr>
  <tr>
    <td width=5%>3493</td>
    <td width=95%> The first operand of this conditional operator is always constant 'true'.</td>
  </tr>
  <tr>
    <td width=5%>3494</td>
    <td width=95%> The first operand of this conditional operator is always constant 'false'.</td>
  </tr>
</table></center>
</td>
    <td width=10%>Portability / Adaptability</td>
    <td>RFAL is configurable through compile time switches. This causes some ifs to have invariant conditions at the used configuration. Suppress 14.3 for if statements.<br></td>
  <tr>
    <td width=4%>Rule-15.5</td>
    <td width=4%>Advisory</td>
    <td width=20%>A function should have a single point of exit at the end</td>
    <td width=2%>1/1</td>
    <td width=30%><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>2889</td>
    <td width=95%> This function has more than one 'return' path.</td>
  </tr>
</table></center>
</td>
    <td width=10%>Maintainability / Analysability</td>
    <td>Suppressed due to readability and simplicity of code logic.<br></td>
  <tr>
    <td width=4%>Rule-17.7</td>
    <td width=4%>Required</td>
    <td width=20%>The value returned by a function having non-void return type shall be used</td>
    <td width=2%>1/1</td>
    <td width=30%><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3200</td>
    <td width=95%> '%s' returns a value which is not being used.</td>
  </tr>
</table></center>
</td>
    <td width=10%>Maintainability / Analysability</td>
    <td>Treating the return codes of functions in all places without exception handling would makes the code hard to read and maintain. Error checking has been reduced to the places where needed.<br></td>
  <tr>
    <td width=4%>Rule-2.1</td>
    <td width=4%>Required</td>
    <td width=20%>A project shall not contain unreachable code</td>
    <td width=2%>1/7</td>
    <td width=30%><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>1503</td>
    <td width=95%> The function '%1s' is defined but is not used within this project.</td>
  </tr>
</table></center>
</td>
    <td width=10%>Maintainability / Modularity</td>
    <td>RFAL provides many functions - some are not used within the checked project.<br></td>
  <tr>
    <td width=4%>Rule-2.2</td>
    <td width=4%>Required</td>
    <td width=20%>There shall be no dead code</td>
    <td width=2%>7/18</td>
    <td width=30%><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>2982</td>
    <td width=95%> This assignment is redundant. The value of this object is never used before being modified.</td>
  </tr>
  <tr>
    <td width=5%>2983</td>
    <td width=95%> This assignment is redundant. The value of this object is never subsequently used.</td>
  </tr>
  <tr>
    <td width=5%>2985</td>
    <td width=95%> This operation is redundant. The value of the result is always that of the left-hand operand.</td>
  </tr>
  <tr>
    <td width=5%>2986</td>
    <td width=95%> This operation is redundant. The value of the result is always that of the right-hand operand.</td>
  </tr>
  <tr>
    <td width=5%>2996</td>
    <td width=95%> The result of this logical operation is always 'false'.</td>
  </tr>
  <tr>
    <td width=5%>2997</td>
    <td width=95%> The first operand of this conditional operator is always 'true'.</td>
  </tr>
  <tr>
    <td width=5%>3112</td>
    <td width=95%> This statement has no side-effect - it can be removed.</td>
  </tr>
</table></center>
</td>
    <td width=10%>Usability / User error protection</td>
    <td>All the violations were checked and fixing the violation would deteriorate robustness: Removing checks which are unnecessary at the given position, removing trailing iterator increment, etc.<br></td>
  <tr>
    <td width=4%>Rule-2.3</td>
    <td width=4%>Advisory</td>
    <td width=20%>A project should not contain unused type declarations</td>
    <td width=2%>1/1</td>
    <td width=30%><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3205</td>
    <td width=95%> The identifier '%s' is not used and could be removed.</td>
  </tr>
</table></center>
</td>
    <td width=10%>Compatibility / Interoperability</td>
    <td>RFAL defines enums for all identifiers available in NFC Forum - some are unused.<br></td>
  <tr>
    <td width=4%>Rule-2.5</td>
    <td width=4%>Advisory</td>
    <td width=20%>A project should not contain unused macro declarations</td>
    <td width=2%>1/1</td>
    <td width=30%><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>3214</td>
    <td width=95%> The macro '%s' is not used and could be removed.</td>
  </tr>
</table></center>
</td>
    <td width=10%>Compatibility / Interoperability</td>
    <td>RFAL defines macros for all identifiers of NFC Forum and RF chip register map - some are not used.<br></td>
  <tr>
    <td width=4%>Rule-8.7</td>
    <td width=4%>Advisory</td>
    <td width=20%>Functions and objects should not be defined with external linkage if they are referenced in only one translation unit</td>
    <td width=2%>4/4</td>
    <td width=30%><center><table width=100%>
  <tr><th>Qac</th><th>Description</th></tr>
  <tr>
    <td width=5%>1504</td>
    <td width=95%> The object '%1s' is only referenced in the translation unit where it is defined.</td>
  </tr>
  <tr>
    <td width=5%>1505</td>
    <td width=95%> The function '%1s' is only referenced in the translation unit where it is defined.</td>
  </tr>
  <tr>
    <td width=5%>1531</td>
    <td width=95%> The object '%1s' is referenced in only one translation unit - but not the one in which it is defined.</td>
  </tr>
  <tr>
    <td width=5%>1532</td>
    <td width=95%> The function '%1s' is only referenced in one translation unit - but not the one in which it is defined.</td>
  </tr>
</table></center>
</td>
    <td width=10%>Maintainability / Modularity</td>
    <td>RFAL defines functions which could be called by the user but are not called in the current project.<br></td>
  </tr>
</table></center>
</div>
<div class="Records">
<div class="sec"><h2><a name="Records">Deviation Records</a></h2></div>
This section targets to provide an overview of Deviation Records.
<br>
<br>
<div class="files">
<div class="sec"><h3><a name="SuppressionsByFile">1. Suppressions by File</a></h3></div>
<h4>File: .../ST25R3916_nucleo/rfal/source/rfal_isoDep.c</h4>
<center><table class="docTable" width=98%>
  <colgroup span="10" class="columns"></colgroup>
  <tr><th>Lines</th><th>Count</th><th>Suppressed Qacs</th><th>Comment</th></tr>
  </tr>
  <tr>
    <td width=4%>2266-2267</td>
    <td align=center width=4%>1</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>0310</td>
    <td width=95%> Casting to different object pointer type.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 11.3 - Intentional safe cast to avoiding buffer duplication</td>
    </tr>
  <tr>
    <td width=4%>421-421</td>
    <td align=center width=4%>1</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>0750</td>
    <td width=95%> A union type specifier has been defined.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 19.2 - Members of the union will not be used concurrently, only one frame at a time</td>
    </tr>
  <tr>
    <td width=4%>797-797</td>
    <td align=center width=4%>1</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>2003</td>
    <td width=95%> The preceding 'switch' clause is not empty and does not end with a 'jump' statement. Execution will fall through.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 16.3 - Intentional fall through</td>
    </tr>
  <tr>
    <td width=4%>2519-2519</td>
    <td align=center width=4%>1</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>4342</td>
    <td width=95%> An expression of 'essentially unsigned' type (%1s) is being cast to enum type '%2s'.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 10.5 - Layout of enum rfalBitRate and above clamping of maxTxBR guarantee no invalid enum values to be created</td>
    </tr>
  <tr>
    <td width=4%>2693-2693</td>
    <td align=center width=4%>1</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>0310</td>
    <td width=95%> Casting to different object pointer type.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 11.3 - Intentional safe cast to avoiding large buffer duplication</td>
    </tr>
  <tr>
    <td width=4%>1351-1351</td>
    <td align=center width=4%>1</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>2003</td>
    <td width=95%> The preceding 'switch' clause is not empty and does not end with a 'jump' statement. Execution will fall through.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 16.3 - Intentional fall through</td>
    </tr>
  <tr>
    <td width=4%>1028-1028</td>
    <td align=center width=4%>1</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>2003</td>
    <td width=95%> The preceding 'switch' clause is not empty and does not end with a 'jump' statement. Execution will fall through.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 16.3 - Intentional fall through</td>
    </tr>
  <tr>
    <td width=4%>2756-2756</td>
    <td align=center width=4%>1</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>2003</td>
    <td width=95%> The preceding 'switch' clause is not empty and does not end with a 'jump' statement. Execution will fall through.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 16.3 - Intentional fall through</td>
    </tr>
  <tr>
    <td width=4%>2615-2615</td>
    <td align=center width=4%>1</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>4342</td>
    <td width=95%> An expression of 'essentially unsigned' type (%1s) is being cast to enum type '%2s'.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 10.5 - Layout of enum rfalBitRate and range of loop variable guarantee no invalid enum values to be created</td>
    </tr>
  <tr>
    <td width=4%>2602-2602</td>
    <td align=center width=4%>1</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>4342</td>
    <td width=95%> An expression of 'essentially unsigned' type (%1s) is being cast to enum type '%2s'.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 10.5 - Layout of enum rfalBitRate and range of loop variable guarantee no invalid enum values to be created</td>
    </tr>
  <tr>
    <td width=4%>2175-2176</td>
    <td align=center width=4%>1</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>4342</td>
    <td width=95%> An expression of 'essentially unsigned' type (%1s) is being cast to enum type '%2s'.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 10.5 - Layout of enum rfalIsoDepFSxI is guaranteed within 4bit range</td>
    </tr>
  <tr>
    <td width=4%>2526-2526</td>
    <td align=center width=4%>1</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>4342</td>
    <td width=95%> An expression of 'essentially unsigned' type (%1s) is being cast to enum type '%2s'.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 10.5 - Layout of enum rfalBitRate and above clamping of maxTxBR guarantee no invalid enum values to be created</td>
    </tr>
  <tr>
    <td width=4%>1391-1393</td>
    <td align=center width=4%>2</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>4342</td>
    <td width=95%> An expression of 'essentially unsigned' type (%1s) is being cast to enum type '%2s'.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 10.5 - Layout of enum rfalBitRate and above masks guarantee no invalid enum values to be created</td>
    </tr>
</table></center>
<h4>File: .../ST25R3916_nucleo/rfal/source/rfal_nfc.c</h4>
<center><table class="docTable" width=98%>
  <colgroup span="10" class="columns"></colgroup>
  <tr><th>Lines</th><th>Count</th><th>Suppressed Qacs</th><th>Comment</th></tr>
  </tr>
  <tr>
    <td width=4%>1612-1612</td>
    <td align=center width=4%>1</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>0310</td>
    <td width=95%> Casting to different object pointer type.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 11.3 - Intentional safe cast to avoiding large buffer duplication</td>
    </tr>
  <tr>
    <td width=4%>81-81</td>
    <td align=center width=4%>1</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>0750</td>
    <td width=95%> A union type specifier has been defined.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 19.2 - Members of the union will not be used concurrently, only one interface at a time</td>
    </tr>
  <tr>
    <td width=4%>190-190</td>
    <td align=center width=4%>1</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>2880</td>
    <td width=95%> This code is unreachable.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 2.1 - Unreachable code due to configuration option being set/unset</td>
    </tr>
  <tr>
    <td width=4%>1828-1828</td>
    <td align=center width=4%>1</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>0310</td>
    <td width=95%> Casting to different object pointer type.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 11.3 - Intentional safe cast to avoiding large buffer duplication</td>
    </tr>
</table></center>
<h4>File: .../ST25R3916_nucleo/rfal/source/rfal_nfcDep.c</h4>
<center><table class="docTable" width=98%>
  <colgroup span="10" class="columns"></colgroup>
  <tr><th>Lines</th><th>Count</th><th>Suppressed Qacs</th><th>Comment</th></tr>
  </tr>
  <tr>
    <td width=4%>1901-1903</td>
    <td align=center width=4%>2</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>4342</td>
    <td width=95%> An expression of 'essentially unsigned' type (%1s) is being cast to enum type '%2s'.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 10.5 - Layout of enum rfalBitRate and definition of rfalNfcDepBRS2DSI guarantee no invalid enum values to be created</td>
    </tr>
  <tr>
    <td width=4%>2595-2595</td>
    <td align=center width=4%>1</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>0310</td>
    <td width=95%> Casting to different object pointer type.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 11.3 - Intentional safe cast to avoiding large buffer duplication</td>
    </tr>
  <tr>
    <td width=4%>1589-1589</td>
    <td align=center width=4%>1</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>2003</td>
    <td width=95%> The preceding 'switch' clause is not empty and does not end with a 'jump' statement. Execution will fall through.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 16.3 - Intentional fall through</td>
    </tr>
  <tr>
    <td width=4%>902-902</td>
    <td align=center width=4%>1</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>2880</td>
    <td width=95%> This code is unreachable.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 2.1 - Guard code to prevent unexpected behavior</td>
    </tr>
  <tr>
    <td width=4%>1661-1661</td>
    <td align=center width=4%>1</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>2003</td>
    <td width=95%> The preceding 'switch' clause is not empty and does not end with a 'jump' statement. Execution will fall through.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 16.3 - Intentional fall through</td>
    </tr>
  <tr>
    <td width=4%>2654-2654</td>
    <td align=center width=4%>1</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>2003</td>
    <td width=95%> The preceding 'switch' clause is not empty and does not end with a 'jump' statement. Execution will fall through.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 16.3 - Intentional fall through</td>
    </tr>
  <tr>
    <td width=4%>1269-1269</td>
    <td align=center width=4%>1</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>2880</td>
    <td width=95%> This code is unreachable.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 2.1 - Guard code to prevent unexpected behavior</td>
    </tr>
</table></center>
<h4>File: .../ST25R3916_nucleo/rfal/source/rfal_nfca.c</h4>
<center><table class="docTable" width=98%>
  <colgroup span="10" class="columns"></colgroup>
  <tr><th>Lines</th><th>Count</th><th>Suppressed Qacs</th><th>Comment</th></tr>
  </tr>
  <tr>
    <td width=4%>278-278</td>
    <td align=center width=4%>1</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>2003</td>
    <td width=95%> The preceding 'switch' clause is not empty and does not end with a 'jump' statement. Execution will fall through.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 16.3 - Intentional fall through</td>
    </tr>
  <tr>
    <td width=4%>637-638</td>
    <td align=center width=4%>1</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>4342</td>
    <td width=95%> An expression of 'essentially unsigned' type (%1s) is being cast to enum type '%2s'.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 10.5 - Guaranteed that no invalid enum values are created: see guard_eq_RFAL_NFCA_T2T, ....</td>
    </tr>
</table></center>
<h4>File: .../ST25R3916_nucleo/rfal/source/rfal_nfcb.c</h4>
<center><table class="docTable" width=98%>
  <colgroup span="10" class="columns"></colgroup>
  <tr><th>Lines</th><th>Count</th><th>Suppressed Qacs</th><th>Comment</th></tr>
  </tr>
  <tr>
    <td width=4%>391-392</td>
    <td align=center width=4%>1</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>4342</td>
    <td width=95%> An expression of 'essentially unsigned' type (%1s) is being cast to enum type '%2s'.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 10.5 - Layout of rfalNfcbSlots and above loop guarantee that no invalid enum values are created.</td>
    </tr>
</table></center>
<h4>File: .../ST25R3916_nucleo/rfal/source/st25r3916/rfal_rfst25r3916.c</h4>
<center><table class="docTable" width=98%>
  <colgroup span="10" class="columns"></colgroup>
  <tr><th>Lines</th><th>Count</th><th>Suppressed Qacs</th><th>Comment</th></tr>
  </tr>
  <tr>
    <td width=4%>3344-3344</td>
    <td align=center width=4%>1</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>2003</td>
    <td width=95%> The preceding 'switch' clause is not empty and does not end with a 'jump' statement. Execution will fall through.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 16.3 - Intentional fall through</td>
    </tr>
  <tr>
    <td width=4%>3108-3108</td>
    <td align=center width=4%>1</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>0759</td>
    <td width=95%> An object of union type has been defined.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 19.2 - Allocating Union where members are of the same type, just different names.  Thus no problem can occur.</td>
    </tr>
  <tr>
    <td width=4%>227-227</td>
    <td align=center width=4%>1</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>0750</td>
    <td width=95%> A union type specifier has been defined.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 19.2 - Both members are of the same type, just different names.  Thus no problem can occur.</td>
    </tr>
  <tr>
    <td width=4%>2046-2046</td>
    <td align=center width=4%>1</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>2003</td>
    <td width=95%> The preceding 'switch' clause is not empty and does not end with a 'jump' statement. Execution will fall through.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 16.3 - Intentional fall through</td>
    </tr>
  <tr>
    <td width=4%>3364-3364</td>
    <td align=center width=4%>1</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>4342</td>
    <td width=95%> An expression of 'essentially unsigned' type (%1s) is being cast to enum type '%2s'.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 10.5 - Guaranteed that no invalid enum values may be created. See also equalityGuard_RFAL_BR_106 ff.</td>
    </tr>
  <tr>
    <td width=4%>2179-2179</td>
    <td align=center width=4%>1</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>2003</td>
    <td width=95%> The preceding 'switch' clause is not empty and does not end with a 'jump' statement. Execution will fall through.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 16.3 - Intentional fall through</td>
    </tr>
  <tr>
    <td width=4%>1867-1867</td>
    <td align=center width=4%>1</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>2003</td>
    <td width=95%> The preceding 'switch' clause is not empty and does not end with a 'jump' statement. Execution will fall through.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 16.3 - Intentional fall through</td>
    </tr>
  <tr>
    <td width=4%>1851-1851</td>
    <td align=center width=4%>1</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>2003</td>
    <td width=95%> The preceding 'switch' clause is not empty and does not end with a 'jump' statement. Execution will fall through.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 16.3 - Intentional fall through</td>
    </tr>
  <tr>
    <td width=4%>2447-2447</td>
    <td align=center width=4%>1</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>2003</td>
    <td width=95%> The preceding 'switch' clause is not empty and does not end with a 'jump' statement. Execution will fall through.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 16.3 - Intentional fall through</td>
    </tr>
  <tr>
    <td width=4%>1972-1972</td>
    <td align=center width=4%>1</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>2003</td>
    <td width=95%> The preceding 'switch' clause is not empty and does not end with a 'jump' statement. Execution will fall through.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 16.3 - Intentional fall through</td>
    </tr>
  <tr>
    <td width=4%>1837-1837</td>
    <td align=center width=4%>1</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>2003</td>
    <td width=95%> The preceding 'switch' clause is not empty and does not end with a 'jump' statement. Execution will fall through.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 16.3 - Intentional fall through</td>
    </tr>
  <tr>
    <td width=4%>2341-2341</td>
    <td align=center width=4%>1</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>2003</td>
    <td width=95%> The preceding 'switch' clause is not empty and does not end with a 'jump' statement. Execution will fall through.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 16.3 - Intentional fall through</td>
    </tr>
  <tr>
    <td width=4%>2254-2254</td>
    <td align=center width=4%>1</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>2003</td>
    <td width=95%> The preceding 'switch' clause is not empty and does not end with a 'jump' statement. Execution will fall through.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 16.3 - Intentional fall through</td>
    </tr>
  <tr>
    <td width=4%>3563-3563</td>
    <td align=center width=4%>1</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>4342</td>
    <td width=95%> An expression of 'essentially unsigned' type (%1s) is being cast to enum type '%2s'.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 10.5 - Guaranteed that no invalid enum values may be created. See also equalityGuard_RFAL_BR_106 ff.</td>
    </tr>
  <tr>
    <td width=4%>1494-1494</td>
    <td align=center width=4%>1</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>5209</td>
    <td width=95%> Use of basic type '%s'.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 4.9 - External function (sqrt()) requires double</td>
    </tr>
</table></center>
</div>
<div class="files">
<div class="sec"><h3><a name="SuppressionsByGroup">2. Suppressions by Group</a></h3></div>
<center><table class="docTable" width=98%>
  <colgroup span="10" class="columns"></colgroup>
  <tr><th>File</th><th>Required</th><th>Advisory</th><th>Total</th></tr>
  <tr>
    <td>.../ST25R3916_nucleo/rfal/include/rfal_nfcv.h</td>
    <td align=center>0</td>
    <td align=center>1</td>
    <td align=center>1</td>
  </tr>
  <tr>
    <td>.../ST25R3916_nucleo/rfal/include/rfal_nfcDep.h</td>
    <td align=center>0</td>
    <td align=center>1</td>
    <td align=center>1</td>
  </tr>
  <tr>
    <td>.../ST25R3916_nucleo/rfal/include/rfal_isoDep.h</td>
    <td align=center>0</td>
    <td align=center>1</td>
    <td align=center>1</td>
  </tr>
  <tr>
    <td>.../ST25R3916_nucleo/rfal/include/rfal_nfc.h</td>
    <td align=center>0</td>
    <td align=center>3</td>
    <td align=center>3</td>
  </tr>
  <tr>
    <td>.../ST25R3916_nucleo/rfal/include/rfal_analogConfig.h</td>
    <td align=center>1</td>
    <td align=center>0</td>
    <td align=center>1</td>
  </tr>
  <tr>
    <td>.../ST25R3916_nucleo/rfal/source/rfal_nfca.c</td>
    <td align=center>1</td>
    <td align=center>1</td>
    <td align=center>2</td>
  </tr>
  <tr>
    <td>.../ST25R3916_nucleo/rfal/source/rfal_nfc.c</td>
    <td align=center>3</td>
    <td align=center>1</td>
    <td align=center>4</td>
  </tr>
  <tr>
    <td>.../ST25R3916_nucleo/rfal/source/rfal_nfcDep.c</td>
    <td align=center>6</td>
    <td align=center>2</td>
    <td align=center>8</td>
  </tr>
  <tr>
    <td>.../ST25R3916_nucleo/rfal/source/rfal_isoDep.c</td>
    <td align=center>6</td>
    <td align=center>8</td>
    <td align=center>14</td>
  </tr>
  <tr>
    <td>.../ST25R3916_nucleo/rfal/source/st25r3916/rfal_rfst25r3916.c</td>
    <td align=center>10</td>
    <td align=center>5</td>
    <td align=center>15</td>
  </tr>
  <tr>
    <td>.../ST25R3916_nucleo/rfal/source/st25r3916/rfal_analogConfigTbl.h</td>
    <td align=center>1</td>
    <td align=center>1</td>
    <td align=center>2</td>
  </tr>
  <tr>
    <td>.../ST25R3916_nucleo/rfal/source/rfal_nfcb.c</td>
    <td align=center>0</td>
    <td align=center>1</td>
    <td align=center>1</td>
  </tr>
  <tr>
    <td><b>Total</b></td>
    <td align=center><b>28</b></td>
    <td align=center><b>25</b></td>
    <td align=center><b>53</b></td>
  </tr>
</table></center>
</div>
<div class="files">
<div class="sec"><h3><a name="RedundantSuppressions">3. Redundant Suppressions</a></h3></div>
<div class="sec"><h4><a name="DuplicatedSuppressions">o Duplicated Suppressions</a></h4></div>
There are no duplicated suppressions.
<div class="sec"><h4><a name="UnusedSuppressions">o Unused Suppressions</a></h4></div>
<h4>File: .../ST25R3916_nucleo/rfal/source/rfal_isoDep.c</h4>
<center><table class="docTable" width=98%>
  <colgroup span="10" class="columns"></colgroup>
  <tr><th>Line</th><th>Unused Qacs</th><th>Comment</th></tr>
  <tr>
    <td width=4%>1414</td>
    <td><center><table width=98%>
  <tr>
    <td width=5%>2880</td>
    <td width=95%> This code is unreachable.</td>
  </tr>
</table></center>
</td>
    <td width=45%>MISRA 2.1 - Unreachable code due to configuration option being set/unset above (RFAL_SUPPORT_BR_CE_A_xxx)</td>
</tr>
</table></center>
</div>
<div class="files">
<div class="sec"><h3><a name="ContinuousSuppressionsByFile">4. Continuous Suppressions by File</a></h3></div>
There are no continuous suppressions by file.
</div>
<div class="files">
<div class="sec"><h3><a name="FileStatus">5. File Status</a></h3></div>
Active Diagnostics refers to diagnostics that are not suppressed (note: no suppressed diagnostics have been taken into account for the calculation of information in this document).
<br>
<br>
<center><table class="docTable" width=98%>
  <colgroup span="10" class="columns"></colgroup>
  <tr><th>Files</th><th>Active Diagnostics</th><th>Violated Rules</th><th>Violation Count</th><th>Compliance Index</th></tr>
  <tr>    <td align=left>.../ST25R3916_nucleo/rfal/include/rfal_analogConfig.h</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>100.00</td>
  </tr>
  <tr>    <td align=left>.../ST25R3916_nucleo/rfal/include/rfal_chip.h</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>100.00</td>
  </tr>
  <tr>    <td align=left>.../ST25R3916_nucleo/rfal/include/rfal_isoDep.h</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>100.00</td>
  </tr>
  <tr>    <td align=left>.../ST25R3916_nucleo/rfal/include/rfal_nfc.h</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>100.00</td>
  </tr>
  <tr>    <td align=left>.../ST25R3916_nucleo/rfal/include/rfal_nfcDep.h</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>100.00</td>
  </tr>
  <tr>    <td align=left>.../ST25R3916_nucleo/rfal/include/rfal_nfca.h</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>100.00</td>
  </tr>
  <tr>    <td align=left>.../ST25R3916_nucleo/rfal/include/rfal_nfcb.h</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>100.00</td>
  </tr>
  <tr>    <td align=left>.../ST25R3916_nucleo/rfal/include/rfal_nfcf.h</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>100.00</td>
  </tr>
  <tr>    <td align=left>.../ST25R3916_nucleo/rfal/include/rfal_nfcv.h</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>100.00</td>
  </tr>
  <tr>    <td align=left>.../ST25R3916_nucleo/rfal/include/rfal_rf.h</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>100.00</td>
  </tr>
  <tr>    <td align=left>.../ST25R3916_nucleo/rfal/include/rfal_st25tb.h</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>100.00</td>
  </tr>
  <tr>    <td align=left>.../ST25R3916_nucleo/rfal/include/rfal_t1t.h</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>100.00</td>
  </tr>
  <tr>    <td align=left>.../ST25R3916_nucleo/rfal/source/rfal_analogConfig.c</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>100.00</td>
  </tr>
  <tr>    <td align=left>.../ST25R3916_nucleo/rfal/source/rfal_crc.c</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>100.00</td>
  </tr>
  <tr>    <td align=left>.../ST25R3916_nucleo/rfal/source/rfal_crc.h</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>100.00</td>
  </tr>
  <tr>    <td align=left>.../ST25R3916_nucleo/rfal/source/rfal_iso15693_2.c</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>100.00</td>
  </tr>
  <tr>    <td align=left>.../ST25R3916_nucleo/rfal/source/rfal_iso15693_2.h</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>100.00</td>
  </tr>
  <tr>    <td align=left>.../ST25R3916_nucleo/rfal/source/rfal_isoDep.c</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>100.00</td>
  </tr>
  <tr>    <td align=left>.../ST25R3916_nucleo/rfal/source/rfal_nfc.c</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>100.00</td>
  </tr>
  <tr>    <td align=left>.../ST25R3916_nucleo/rfal/source/rfal_nfcDep.c</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>100.00</td>
  </tr>
  <tr>    <td align=left>.../ST25R3916_nucleo/rfal/source/rfal_nfca.c</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>100.00</td>
  </tr>
  <tr>    <td align=left>.../ST25R3916_nucleo/rfal/source/rfal_nfcb.c</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>100.00</td>
  </tr>
  <tr>    <td align=left>.../ST25R3916_nucleo/rfal/source/rfal_nfcf.c</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>100.00</td>
  </tr>
  <tr>    <td align=left>.../ST25R3916_nucleo/rfal/source/rfal_nfcv.c</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>100.00</td>
  </tr>
  <tr>    <td align=left>.../ST25R3916_nucleo/rfal/source/rfal_st25tb.c</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>100.00</td>
  </tr>
  <tr>    <td align=left>.../ST25R3916_nucleo/rfal/source/rfal_t1t.c</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>100.00</td>
  </tr>
  <tr>    <td align=left>.../ST25R3916_nucleo/rfal/source/st25r3916/rfal_analogConfigTbl.h</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>100.00</td>
  </tr>
  <tr>    <td align=left>.../ST25R3916_nucleo/rfal/source/st25r3916/rfal_features.h</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>100.00</td>
  </tr>
  <tr>    <td align=left>.../ST25R3916_nucleo/rfal/source/st25r3916/rfal_rfst25r3916.c</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>100.00</td>
  </tr>
  <tr>    <td align=left>.../ST25R3916_nucleo/rfal/source/st25r3916/st25R3916_irq.h</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>100.00</td>
  </tr>
  <tr>    <td align=left>.../ST25R3916_nucleo/rfal/source/st25r3916/st25r3916.c</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>100.00</td>
  </tr>
  <tr>    <td align=left>.../ST25R3916_nucleo/rfal/source/st25r3916/st25r3916.h</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>100.00</td>
  </tr>
  <tr>    <td align=left>.../ST25R3916_nucleo/rfal/source/st25r3916/st25r3916_com.c</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>100.00</td>
  </tr>
  <tr>    <td align=left>.../ST25R3916_nucleo/rfal/source/st25r3916/st25r3916_com.h</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>100.00</td>
  </tr>
  <tr>    <td align=left>.../ST25R3916_nucleo/rfal/source/st25r3916/st25r3916_irq.c</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>100.00</td>
  </tr>
  <tr>    <td align=left>.../ST25R3916_nucleo/rfal/source/st25r3916/st25r3916_irq.h</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>100.00</td>
  </tr>
  <tr>    <td align=left>.../ST25R3916_nucleo/rfal/source/st25r3916/st25r3916_led.c</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>100.00</td>
  </tr>
  <tr>    <td align=left>.../ST25R3916_nucleo/rfal/source/st25r3916/st25r3916_led.h</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>0</td>
    <td align=right>100.00</td>
  </tr>
  <tr>    <td><b>Total</b></td>
    <td align=right><b>0</b></td>
    <td align=right><b>0</b></td>
    <td align=right><b>0</b></td>
    <td align=right><b>100.00</b></td>
  </tr>
</table></center>

<br><br>
<b>Nota: Calculation of Compliance Index</b><br>
The Compliance Index is the percentage of groups which have no messages in them.<br>
For each file it is calculated as follows:<br>
<br>
( Ntotal - Nerror  ) / Ntotal  x 100<br>
<br>
Ntotal  is the total number of enforced rules (i.e. the number of rules that have at least one message mapped to it directly).<br>
Nerror  is the number of rules for which messages appear in that file.<br>
The File Compliance Index is the mean of all the individual file compliances.<br>

<br>
</div>
</div>
</div>
 </body>
</html>
